@aleph-alpha/chat-kit 3.2.0 → 4.0.0

package/src/handlers/useMessageHandler.ts

@@ -3,6 +3,7 @@ import {
   addNode as treeAddNode,
   createEmptyTree,
   cutBranchAfter as treeCutBranchAfter,
+  cutBranchAt as treeCutBranchAt,
   getLinearPath,
   navigate as treeNavigate,
   updateNode,
@@ -30,6 +31,19 @@ export const useMessageHandler = () => {
     return list.length > 0 ? list[list.length - 1].id : null;
   });
 
+  /**
+   * Resolve the parent a new node should hang off. When an explicit
+   * `parentId` is given it must reference an existing node; otherwise the
+   * current leaf is used so messages append to the active branch.
+   */
+  function resolveParentId(parentId?: string): string | null {
+    if (parentId === undefined) return currentLeafId.value;
+    if (!tree.nodes[parentId]) {
+      throw new Error(`Unknown parent message id: ${parentId}`);
+    }
+    return parentId;
+  }
+
   function setCurrentUserMessage(text: string) {
     currentUserMessage.value = text;
   }
@@ -38,20 +52,31 @@ export const useMessageHandler = () => {
     currentUserMessage.value = '';
   }
 
+  /**
+   * Commit the pending user message as a new node.
+   *
+   * By default the node is appended to the current leaf. Pass `parentId` to
+   * branch off an arbitrary message instead: the new node becomes a sibling
+   * of that parent's existing children, the parent's `childrenIds` gains the
+   * new id, and the branch is made active.
+   */
   function commitUserMessage(opts?: {
     metadata?: MessageMetadata;
+    parentId?: string;
   }): BaseMessage {
     const id = generateId();
     const text = currentUserMessage.value.trim();
     if (!text) throw new Error('No message');
 
+    const parentId = resolveParentId(opts?.parentId);
+
     const content: MessageContent[] = [
       { type: 'text', id: generateId(), text, status: 'completed' },
     ];
 
     const node: TreeMessage = {
       id,
-      parentId: currentLeafId.value,
+      parentId,
       childrenIds: [],
       activeChildIndex: 0,
       role: 'user',
@@ -75,12 +100,20 @@ export const useMessageHandler = () => {
     return base;
   }
 
+  /**
+   * Upsert a message by id. When the node does not yet exist it is created;
+   * pass `parentId` to branch the new node off an arbitrary message instead
+   * of the current leaf (the parent's `childrenIds` is updated and the new
+   * branch is made active). `parentId` is ignored when the node already
+   * exists.
+   */
   function updateMessage(message: {
     id: string;
     content: MessageContent[];
     role: MessageRole;
     status: MessageStatus;
     metadata?: MessageMetadata;
+    parentId?: string;
   }) {
     const existing = tree.nodes[message.id];
 
@@ -96,7 +129,7 @@ export const useMessageHandler = () => {
     } else {
       const node: TreeMessage = {
         id: message.id,
-        parentId: currentLeafId.value,
+        parentId: resolveParentId(message.parentId),
         childrenIds: [],
         activeChildIndex: 0,
         role: message.role,
@@ -159,6 +192,19 @@ export const useMessageHandler = () => {
     treeCutBranchAfter(tree, messageId);
   }
 
+  /**
+   * Drop the message with `messageId` and its whole subtree, leaving sibling
+   * branches intact (the parent's active branch is clamped to a survivor).
+   * Use to discard one answer among several without cropping the others.
+   */
+  function cutBranchAt(messageId: string) {
+    treeCutBranchAt(tree, messageId);
+  }
+
+  function getTree() {
+    return readonly(tree);
+  }
+
   return {
     messages: messages as Ref<BaseMessage[]>,
     currentUserMessage: readonly(currentUserMessage),
@@ -173,5 +219,7 @@ export const useMessageHandler = () => {
     setTree,
     navigate,
     cutBranchAfter,
+    cutBranchAt,
+    getTree,
   };
 };

package/src/helpers/conversationTree.spec.ts

@@ -8,6 +8,7 @@ import {
   addNode,
   createEmptyTree,
   cutBranchAfter,
+  cutBranchAt,
   getLinearPath,
   navigate,
   updateNode,
@@ -519,6 +520,125 @@ describe('cutBranchAfter', () => {
   });
 });
 
+describe('cutBranchAt', () => {
+  it('removes the target node and its entire subtree', () => {
+    const tree = makeBranchingTree();
+
+    cutBranchAt(tree, 'a1');
+
+    expect(tree.nodes.a1).toBeUndefined();
+    expect(tree.nodes.u2).toBeUndefined();
+    expect(tree.nodes.a2).toBeUndefined();
+    expect(tree.nodes.a3).toBeUndefined();
+  });
+
+  it('leaves sibling branches intact and unlinks from the parent', () => {
+    const tree = makeBranchingTree();
+
+    cutBranchAt(tree, 'a1');
+
+    expect(tree.nodes.a1b).toBeDefined();
+    expect(tree.nodes.u3).toBeDefined();
+    expect(tree.nodes.u1.childrenIds).toEqual(['a1b']);
+  });
+
+  it('clamps the parent activeChildIndex to a surviving sibling', () => {
+    const tree = makeBranchingTree();
+    // u2 → [a2, a3] with a3 active; removing a3 must not leave a dangling index.
+    tree.nodes.u2.activeChildIndex = 1;
+
+    cutBranchAt(tree, 'a3');
+
+    expect(tree.nodes.u2.childrenIds).toEqual(['a2']);
+    expect(tree.nodes.u2.activeChildIndex).toBe(0);
+    expect(getLinearPath(tree).map((m) => m.id)).toEqual([
+      'u1',
+      'a1',
+      'u2',
+      'a2',
+    ]);
+  });
+
+  // Parent with three sibling branches; needs ≥3 so removing an earlier
+  // sibling leaves the active index in-bounds (the clamp alone wouldn't catch
+  // a stale index, only an out-of-range one).
+  function makeThreeSiblingTree(): ConversationTree {
+    return makeTree(
+      {
+        p: makeTreeMessage({ id: 'p', role: 'user', content: [text('Q')] }),
+        cA: makeTreeMessage({
+          id: 'cA',
+          parentId: 'p',
+          role: 'assistant',
+          content: [text('A')],
+        }),
+        cB: makeTreeMessage({
+          id: 'cB',
+          parentId: 'p',
+          role: 'assistant',
+          content: [text('B')],
+        }),
+        cC: makeTreeMessage({
+          id: 'cC',
+          parentId: 'p',
+          role: 'assistant',
+          content: [text('C')],
+        }),
+      },
+      'p',
+    );
+  }
+
+  it('keeps the active branch on the same child when an earlier sibling is removed', () => {
+    const tree = makeThreeSiblingTree();
+    tree.nodes.p.activeChildIndex = 1; // cB active
+    // Removing cA shifts cB/cC down one slot; the active pointer must follow.
+    cutBranchAt(tree, 'cA');
+
+    expect(tree.nodes.p.childrenIds).toEqual(['cB', 'cC']);
+    expect(tree.nodes.p.activeChildIndex).toBe(0);
+    expect(getLinearPath(tree).map((m) => m.id)).toEqual(['p', 'cB']);
+  });
+
+  it('leaves the active index unchanged when a later sibling is removed', () => {
+    const tree = makeThreeSiblingTree();
+    tree.nodes.p.activeChildIndex = 0; // cA active
+    cutBranchAt(tree, 'cC');
+
+    expect(tree.nodes.p.childrenIds).toEqual(['cA', 'cB']);
+    expect(tree.nodes.p.activeChildIndex).toBe(0);
+    expect(getLinearPath(tree).map((m) => m.id)).toEqual(['p', 'cA']);
+  });
+
+  it('falls through to the next sibling when the active child itself is removed', () => {
+    const tree = makeThreeSiblingTree();
+    tree.nodes.p.activeChildIndex = 0; // cA active
+    cutBranchAt(tree, 'cA');
+
+    expect(tree.nodes.p.childrenIds).toEqual(['cB', 'cC']);
+    expect(tree.nodes.p.activeChildIndex).toBe(0);
+    expect(getLinearPath(tree).map((m) => m.id)).toEqual(['p', 'cB']);
+  });
+
+  it('clears the tree when the root is removed', () => {
+    const tree = makeBranchingTree();
+
+    cutBranchAt(tree, 'u1');
+
+    expect(tree.nodes).toEqual({});
+    expect(tree.rootId).toBeNull();
+  });
+
+  it('is a no-op for a nonexistent id', () => {
+    const tree = makeBranchingTree();
+    const before = Object.keys(tree.nodes).sort();
+
+    cutBranchAt(tree, 'nonexistent');
+
+    expect(Object.keys(tree.nodes).sort()).toEqual(before);
+  });
+});
+
 describe('integration: full branching scenario', () => {
   it('simulates send → regenerate → navigate workflow', () => {
     const tree = createEmptyTree();

package/src/helpers/conversationTree.ts

@@ -105,6 +105,21 @@ export function updateNodeId(
   if (tree.rootId === oldId) tree.rootId = newId;
 }
 
+/**
+ * Delete the given node ids and every descendant beneath them from
+ * `tree.nodes`. Does not touch parent links — callers fix those up.
+ */
+function deleteSubtrees(tree: ConversationTree, ids: readonly string[]): void {
+  const stack: string[] = [...ids];
+  while (stack.length > 0) {
+    const currentId = stack.pop() as string;
+    const current = tree.nodes[currentId];
+    if (!current) continue;
+    stack.push(...current.childrenIds);
+    delete tree.nodes[currentId];
+  }
+}
+
 /**
  * Remove every descendant of the node with the given id, keeping the node
  * itself intact. The node's `childrenIds` is cleared and `activeChildIndex`
@@ -117,19 +132,53 @@ export function cutBranchAfter(tree: ConversationTree, id: string): void {
   const node = tree.nodes[id];
   if (!node) return;
 
-  const stack: string[] = [...node.childrenIds];
-  while (stack.length > 0) {
-    const currentId = stack.pop() as string;
-    const current = tree.nodes[currentId];
-    if (!current) continue;
-    stack.push(...current.childrenIds);
-    delete tree.nodes[currentId];
-  }
+  deleteSubtrees(tree, node.childrenIds);
 
   node.childrenIds = [];
   node.activeChildIndex = 0;
 }
 
+/**
+ * Remove the node with the given id *and* its entire subtree, then unlink it
+ * from its parent. Unlike {@link cutBranchAfter} (which keeps the target and
+ * drops only its descendants), this drops the target branch as a whole while
+ * leaving sibling branches intact — use it to discard one answer among several
+ * (e.g. an interrupted regenerate) without cropping the others.
+ *
+ * The parent's `activeChildIndex` is clamped to a remaining sibling so the
+ * active path stays valid. Removing the root clears the tree.
+ *
+ * Prefer {@link cutBranchAfter} when it fits the case: unlinking here scans
+ * and splices the parent's `childrenIds` (O(siblings)), whereas
+ * `cutBranchAfter` only clears the target's own `childrenIds`.
+ */
+export function cutBranchAt(tree: ConversationTree, id: string): void {
+  const node = tree.nodes[id];
+  if (!node) return;
+
+  deleteSubtrees(tree, [id]);
+
+  if (node.parentId === null) {
+    if (tree.rootId === id) tree.rootId = null;
+    return;
+  }
+
+  const parent = tree.nodes[node.parentId];
+  if (!parent) return;
+
+  const idx = parent.childrenIds.indexOf(id);
+  if (idx !== -1) {
+    parent.childrenIds.splice(idx, 1);
+    // Removing a sibling positioned before the active one shifts every later
+    // child's index down by one; decrement so the active branch keeps pointing
+    // at the same child rather than silently jumping to its neighbour.
+    if (idx < parent.activeChildIndex) parent.activeChildIndex -= 1;
+  }
+  if (parent.activeChildIndex >= parent.childrenIds.length) {
+    parent.activeChildIndex = Math.max(0, parent.childrenIds.length - 1);
+  }
+}
+
 /**
  * Navigate to a different branch by updating the parent's activeChildIndex
  * to point at the target sibling.

package/src/helpers/unified/remarkCitations.spec.ts

@@ -0,0 +1,112 @@
+import { remarkCitations } from './remarkCitations';
+
+// The plugin is a pure mdast transformer, so we can exercise it directly on a
+// hand-built tree without spinning up the full unified/remark parser.
+interface MdNode {
+  type: string;
+  value?: string;
+  children?: MdNode[];
+  data?: Record<string, unknown>;
+}
+
+function rootWithText(text: string): MdNode {
+  return { type: 'root', children: [{ type: 'text', value: text }] };
+}
+
+// `remarkCitations` is typed as a unified `Plugin` (it expects a `Processor`
+// `this`). In these unit tests we call it as a plain factory, so cast away the
+// `this` context to invoke it directly on a hand-built tree.
+const makeTransformer = remarkCitations as unknown as (options: {
+  indices?: ReadonlySet<number>;
+}) => (tree: MdNode) => void;
+
+function run(text: string, indices?: ReadonlySet<number>): MdNode[] {
+  const tree = rootWithText(text);
+  makeTransformer({ indices })(tree);
+  return tree.children!;
+}
+
+describe('remarkCitations', () => {
+  it('replaces a known [n] marker with a citation placeholder node', () => {
+    const out = run('see this [1] here', new Set([1]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'text',
+    ]);
+    expect(out[0]).toEqual({ type: 'text', value: 'see this ' });
+    expect(out[2]).toEqual({ type: 'text', value: ' here' });
+  });
+
+  it('emits a span placeholder with the index as a data attribute', () => {
+    const [citation] = run('[1]', new Set([1]));
+    expect(citation.data).toEqual({
+      hName: 'span',
+      hProperties: { 'data-citation-index': 1 },
+      hChildren: [{ type: 'text', value: '1' }],
+    });
+  });
+
+  it('handles adjacent markers', () => {
+    const out = run('claim [1][2] end', new Set([1, 2]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'citationReference',
+      'text',
+    ]);
+    expect(
+      (out[1].data!.hProperties as Record<string, number>)[
+        'data-citation-index'
+      ],
+    ).toBe(1);
+    expect(
+      (out[2].data!.hProperties as Record<string, number>)[
+        'data-citation-index'
+      ],
+    ).toBe(2);
+  });
+
+  it('leaves unsupported markers (no matching source) as literal text', () => {
+    const out = run('real [1] but [9] is not', new Set([1]));
+    expect(out.map((n) => n.type)).toEqual([
+      'text',
+      'citationReference',
+      'text',
+    ]);
+    // The [9] survives verbatim in the trailing text node.
+    expect(out[2].value).toBe(' but [9] is not');
+  });
+
+  it('treats every [n] as a citation when no index set is given', () => {
+    const out = run('a [1] b [2]');
+    expect(out.filter((n) => n.type === 'citationReference')).toHaveLength(2);
+  });
+
+  it('never converts [0] — citations are 1-based', () => {
+    const out = run('the value arr[0] here'); // no allow-list: every [n] except 0
+    expect(out.some((n) => n.type === 'citationReference')).toBe(false);
+    expect(out.map((n) => n.value ?? '').join('')).toContain('[0]');
+  });
+
+  it('leaves text without markers untouched', () => {
+    const out = run('no citations here', new Set([1]));
+    expect(out).toEqual([{ type: 'text', value: 'no citations here' }]);
+  });
+
+  it('does not descend into code/inlineCode value nodes', () => {
+    const tree: MdNode = {
+      type: 'root',
+      children: [
+        { type: 'inlineCode', value: 'arr[1]' },
+        { type: 'text', value: ' and [1]' },
+      ],
+    };
+    makeTransformer({ indices: new Set([1]) })(tree);
+    // inlineCode is untouched; only the text node's [1] becomes a citation.
+    expect(tree.children![0]).toEqual({ type: 'inlineCode', value: 'arr[1]' });
+    expect(tree.children!.some((n) => n.type === 'citationReference')).toBe(
+      true,
+    );
+  });
+});

package/src/helpers/unified/remarkCitations.ts

@@ -0,0 +1,55 @@
+import type { Plugin } from 'unified';
+import type { PhrasingContent } from 'mdast';
+import { findAndReplace } from 'mdast-util-find-and-replace';
+
+export interface RemarkCitationsOptions {
+  /**
+   * When provided, only `[n]` markers whose number is in this set are turned
+   * into citation placeholders; any other `[n]` is left as literal text
+   * (an "unsupported" marker with no backing source). When omitted, every
+   * `[n]` is treated as a citation.
+   */
+  indices?: ReadonlySet<number>;
+}
+
+// Matches a bare `[n]` reference, e.g. `[1]`. Because this runs on the parsed
+// mdast tree (via `findAndReplace`, which only visits `text` nodes), `[n]`
+// inside code spans/blocks and bracketed links never reaches it — only a
+// literal `[n]` typed in prose does.
+const CITATION_RE = /\[(\d+)\]/g;
+
+/**
+ * Replaces inline `[n]` citation references in the parsed markdown with a
+ * placeholder element (`<span data-citation-index="n">n</span>`) that survives
+ * stringify + sanitisation (`data-*` attributes are allowed by default).
+ */
+// The tree type is left as unified's default (a unist `Node`) so the public
+// type signature — and therefore the published `.d.ts` — doesn't depend on
+// `mdast` types; the cast below keeps the internal `findAndReplace` call typed.
+export const remarkCitations: Plugin<[RemarkCitationsOptions?]> = (
+  options = {},
+) => {
+  const { indices } = options;
+
+  return (tree) => {
+    findAndReplace(tree as Parameters<typeof findAndReplace>[0], [
+      CITATION_RE,
+      (_match: string, digits: string) => {
+        const index = Number(digits);
+        if (index < 1) return false; // citations are 1-based
+        // Leave unsupported markers (no backing source) as literal text.
+        if (indices && !indices.has(index)) return false;
+        return {
+          type: 'citationReference',
+          data: {
+            hName: 'span',
+            // Use the literal attribute name so the placeholder contract matches
+            // the renderer's `getAttribute('data-citation-index')` lookup exactly.
+            hProperties: { 'data-citation-index': index },
+            hChildren: [{ type: 'text', value: String(index) }],
+          },
+        } as unknown as PhrasingContent;
+      },
+    ]);
+  };
+};

package/src/index.ts

@@ -63,9 +63,11 @@ export type {
 // Components
 export {
   CkAgentMessage,
+  CkCitation,
+  CkCitationCard,
   CkConversation,
   CkConversationLayout,
-  CkCopyMessageActionButton,
+  CkCopyMessageButton,
   CkDropZoneOverlay,
   CkFeedbackButton,
   CkFeedbackDialog,
@@ -75,18 +77,24 @@ export {
   CkHistoryWrapper,
   CkInput,
   CkMarkdownRenderer,
-  CkMessageActionButton,
+  CkMessageButton,
   CkModelSelector,
   CkPromptSendButton,
   CkPromptMenuButton,
   CkPromptStopButton,
   CkPromptInput,
   CkPromptInputDisclaimer,
+  CkRegenerateMessageButton,
   CkSendIcon,
   CkStopIcon,
   CkUserMessage,
 } from './components';
 export type {
+  CkCitationProps,
+  CkCitationEmits,
+  CkCitationSource,
+  CkCitationCardProps,
+  CkCitationCardEmits,
   CkConversationLayoutProps,
   CkConversationProps,
   CkDropZoneOverlayProps,
@@ -110,6 +118,7 @@ export type {
   CkHistoryWrapperProps,
   CkMarkdownElementClasses,
   CkMarkdownRendererProps,
+  CkMarkdownRendererEmits,
   CkModelOption,
   CkModelSelectorProps,
   CkModelSelectorEmits,

package/dist/components/base/CkCopyMessageActionButton/CkCopyMessageActionButton.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CkCopyMessageActionButton.stories.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkCopyMessageActionButton/CkCopyMessageActionButton.stories.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,MAAM,iCAAiC,CAAC;AACxE,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAE3D,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,yBAAyB,CAwBhD,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAkBnC;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,KAKrB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,EAAE,KAMtB,CAAC"}

package/dist/components/base/CkCopyMessageActionButton/CkCopyMessageActionButton.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CkCopyMessageActionButton.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkCopyMessageActionButton/CkCopyMessageActionButton.vue"],"names":[],"mappings":"AAkHA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,SAAS,CAAC;AA+M9D,QAAA,MAAM,YAAY;;iBA7LW,OAAO;;;;iBAAP,OAAO;;;;;;;;6EAiMlC,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/base/CkCopyMessageActionButton/index.d.ts

@@ -1,3 +0,0 @@
-export { default as CkCopyMessageActionButton } from './CkCopyMessageActionButton.vue';
-export type * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/base/CkCopyMessageActionButton/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkCopyMessageActionButton/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,8BAA8B;IAC7C,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED,MAAM,WAAW,8BAA8B;IAC7C,2EAA2E;IAC3E,CAAC,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;CAClD"}

package/dist/components/base/CkMessageActionButton/CkMessageActionButton.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CkMessageActionButton.stories.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkMessageActionButton/CkMessageActionButton.stories.ts"],"names":[],"mappings":"AAAA,OAAO,qBAAqB,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAG3D,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,qBAAqB,CAqB5C,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAanC;;;GAGG;AACH,eAAO,MAAM,OAAO,EAAE,KAUrB,CAAC"}

package/dist/components/base/CkMessageActionButton/CkMessageActionButton.vue.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CkMessageActionButton.vue.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkMessageActionButton/CkMessageActionButton.vue"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,SAAS,CAAC;AAwD1D,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAK/C,QAAA,MAAM,UAAU;;6EAGd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/base/CkMessageActionButton/index.d.ts

@@ -1,3 +0,0 @@
-export { default as CkMessageActionButton } from './CkMessageActionButton.vue';
-export type * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/components/base/CkMessageActionButton/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkMessageActionButton/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,6BAA6B,CAAC;AAC/E,mBAAmB,SAAS,CAAC"}

package/dist/components/base/CkMessageActionButton/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/components/base/CkMessageActionButton/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB"}

package/src/components/base/CkCopyMessageActionButton/index.ts

@@ -1,2 +0,0 @@
-export { default as CkCopyMessageActionButton } from './CkCopyMessageActionButton.vue';
-export type * from './types';

package/src/components/base/CkMessageActionButton/index.ts

@@ -1,2 +0,0 @@
-export { default as CkMessageActionButton } from './CkMessageActionButton.vue';
-export type * from './types';