@aparte/core 0.2.0-alpha.0

package/dist/components/viewport/aparte-chat-viewport.d.ts

@@ -0,0 +1,358 @@
+import type { AparteMessage, AparteViewportConfig, AparteSegment, AparteUsage } from '../../types/index.js';
+import type { ExportedMessageRepository } from '../../runtime/message-repository.js';
+/**
+ * AparteChatViewport - The Core
+ *
+ * Container component with smart scroll, streaming, and segment support.
+ * Uses Light DOM for global CSS styling.
+ *
+ * @element aparte-chat-viewport
+ *
+ * Features:
+ * - Smart Scroll: Sticks to bottom when user is at bottom, stops on manual scroll up
+ * - appendToken(): For simple content streaming
+ * - appendToSegment(): For segment-aware streaming (thinking, code, etc.)
+ * - Internal message registry for memory management
+ */
+export declare class AparteChatViewport extends HTMLElement {
+    private _container;
+    private _scrollBtn;
+    private _bottomSpacer;
+    /**
+     * In framework-managed mode there is no spacer ELEMENT (an extra child would
+     * collide with the framework's own DOM reconciliation). The spacer is an
+     * additive `padding-bottom` on the host, tracked here so `_recalculateSpacer`
+     * can read the current value without measuring an element.
+     */
+    private _fwSpacerHeight;
+    private _spacerRafId;
+    private _spacerFrozenUntil;
+    private _layoutTransitionMs;
+    private _repo;
+    private _isAutoScrollEnabled;
+    private _scrollThreshold;
+    /** When true, the next _autoScroll() call uses smooth instead of instant, then resets. */
+    private _smoothScrollOnce;
+    /**
+     * DOM render cap: the max number of `<aparte-chat-bubble>` elements kept in the
+     * DOM at once (a perf ceiling for very long conversations). This NEVER evicts
+     * messages from the repository — the full conversation tree and its persistence
+     * snapshot stay intact; only the oldest rendered bubbles are dropped from view.
+     */
+    private _maxRenderedBubbles;
+    /** One-time guard for the deprecated `maxMessages` warning. */
+    private _warnedMaxMessagesDeprecation;
+    private _resizeObserver;
+    private _mutationObserver;
+    private _boundResetHandler;
+    /**
+     * When true, _reRenderActivePath() only dispatches aparte-path-changed without
+     * touching the DOM. Set via setFrameworkManagedDOM(true) when a framework
+     * (e.g. Angular) owns the bubble elements.
+     */
+    private _frameworkManagedDOM;
+    static get observedAttributes(): string[];
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+    /**
+     * Configure viewport with options
+     */
+    configure(config: AparteViewportConfig): void;
+    /**
+     * Append a token chunk to a message's content (simple text streaming)
+     * @param messageId - Unique identifier for the message
+     * @param chunk - Token chunk to append
+     */
+    appendToken(messageId: string, chunk: string): void;
+    /**
+     * Append content to a specific segment within a message
+     * @param messageId - Message containing the segment
+     * @param segmentId - Target segment ID
+     * @param chunk - Content to append
+     */
+    appendToSegment(messageId: string, segmentId: string, chunk: string): void;
+    /**
+     * The active (head) message id — the target of `AparteClient`'s 1-argument
+     * streaming convention (`addSegment(segment)`, `updateSegment(segmentId,
+     * updates)`, …) which operates on "the current message". Lets a bare
+     * `<aparte-chat-viewport>` be a valid `AparteClient` target, exactly like a
+     * framework wrapper's host element.
+     */
+    private _activeMessageId;
+    /**
+     * Add a new segment. Two calling conventions are accepted:
+     * - `addSegment(segment)` — AparteClient's 1-arg "operate on the current
+     *   (head) message" convention (also what a wrapper host installs);
+     * - `addSegment(messageId, segment)` — explicit standalone form.
+     * The first argument's type disambiguates (string = messageId, object =
+     * segment), so a raw viewport driven by `AparteClient` no longer drops text
+     * (the args used to bind one position short, creating a phantom message).
+     */
+    addSegment(segment: AparteSegment): void;
+    addSegment(messageId: string, segment: AparteSegment): void;
+    /**
+     * Update a segment. `updateSegment(segmentId, updates)` (1-arg client
+     * convention → current message) or `updateSegment(messageId, segmentId,
+     * updates)` (explicit). Disambiguated by arity: the 3rd arg is absent and
+     * the 2nd is the `updates` object in the 1-arg form.
+     */
+    updateSegment(segmentId: string, updates: Partial<AparteSegment>): void;
+    updateSegment(messageId: string, segmentId: string, updates: Partial<AparteSegment>): void;
+    /**
+     * Remove a segment. `removeSegment(segmentId)` (1-arg client convention →
+     * current message) or `removeSegment(messageId, segmentId)` (explicit).
+     */
+    removeSegment(segmentId: string): void;
+    removeSegment(messageId: string, segmentId: string): void;
+    /**
+     * Start a new streaming segment (e.g., thinking or code block)
+     * Creates the segment and marks it as streaming
+     */
+    startSegment(messageId: string, segment: AparteSegment): void;
+    /**
+     * Complete a streaming segment
+     */
+    completeSegment(messageId: string, segmentId: string): void;
+    /**
+     * Persist token usage on a message and propagate to the live bubble so the
+     * perf chip (tokens/sec) renders in the action bar.
+     */
+    setUsage(messageId: string, usage: AparteUsage): void;
+    /**
+     * Mark a message as finished streaming
+     */
+    completeMessage(messageId: string): void;
+    /**
+     * Atomic update for a message by ID
+     * Supports updating content, status, segments, and other metadata
+     */
+    updateMessage(messageId: string, updates: Partial<AparteMessage>): void;
+    /**
+     * Add a complete message to the message registry.
+     *
+     * @remarks
+     * **Framework-managed DOM only.** Records the message in the tree but does NOT
+     * paint a bubble on its own (a framework wrapper reconciles the DOM from the
+     * list). For standalone / vanilla usage call {@link appendMessage} instead,
+     * which both records the message and creates its bubble element.
+     */
+    addMessage(message: AparteMessage): void;
+    /**
+     * Append a new message and create its bubble in the DOM.
+     * Implements the same contract as the Angular wrapper's appendMessage(),
+     * making aparte-chat-viewport a fully standalone target for aparte-client.
+     * When `_frameworkManagedDOM` is true, only the internal repo is updated —
+     * the framework owns the DOM and will create the bubble element itself.
+     */
+    appendMessage(message: AparteMessage): void;
+    /**
+     * Update the last message content, optionally appending.
+     * Implements the same contract as the Angular wrapper's updateLastMessage(),'
+     * making aparte-chat-viewport a fully standalone streaming target for aparte-client.
+     */
+    updateLastMessage(content: string, options?: {
+        append?: boolean;
+    }): void;
+    /**
+     * Add a new sibling branch to an assistant message (retry flow).
+     * Creates a new empty assistant message as a sibling of `messageId`
+     * under the same parent, switches the active branch to it, and
+     * re-renders the active path.
+     * @returns The index of the new branch in the siblings array, or 0 on failure.
+     */
+    addBranch(messageId: string): number;
+    /**
+     * Add a new message relative to `existingId`, switch to it, and re-render.
+     *
+     * Role-aware semantics:
+     *  - existingId is an **assistant** message → create a sibling (same parent),
+     *    so the active path replaces the old response with the new one.
+     *  - existingId is a **user** message → create a child of that message,
+     *    so the user message stays on the active path and the new response follows it.
+     *
+     * Returns the new message's ID, or null if `existingId` is not found.
+     */
+    addSiblingOf(existingId: string, newMessage: AparteMessage): string | null;
+    /**
+     * Navigate to the previous or next sibling branch of a message.
+     * Triggers a full re-render of the active path.
+     */
+    navigateBranch(messageId: string, direction: 'prev' | 'next'): void;
+    /**
+     * Remove ALL responses to a user message (every child branch) and set head
+     * back to `userMessageId`. Cleaner than `truncateFrom` for edit flows: it
+     * discards stale sibling branches so the regenerated response starts alone.
+     */
+    truncateResponsesAfter(userMessageId: string): void;
+    /**
+     * Remove all messages from `messageId` onwards (inclusive) from state and DOM.
+     * Used by edit to truncate history before re-generating.
+     */
+    truncateFrom(messageId: string): void;
+    /**
+     * Get a message by ID
+     */
+    getMessage(messageId: string): AparteMessage | undefined;
+    getMessages(): AparteMessage[];
+    /**
+     * Export the full conversation tree (all branches, not just the active path).
+     * The returned snapshot can be persisted and restored via `importTree()`.
+     */
+    exportTree(): ExportedMessageRepository;
+    /**
+     * Import a previously-exported tree snapshot, restoring the full branch
+     * topology and the active head. Replaces any existing repo content.
+     *
+     * Always calls `_reRenderActivePath()`:
+     * - In native DOM mode: rebuilds bubble elements.
+     * - In framework-managed mode: skips DOM manipulation but dispatches
+     *   `aparte-path-changed` with sibling metadata so the wrapper can update
+     *   branch arrows on already-rendered bubbles.
+     */
+    importTree(tree: ExportedMessageRepository): void;
+    /**
+     * Clear all messages and remove all bubble elements from the DOM.
+     * Also dispatches a aparte-reset-done event.
+     *
+     * In framework-managed mode the DOM is owned by the host framework
+     * (Angular @for, React, etc.) and we must not clear `innerHTML` — doing
+     * so desynchronises the framework's view tree from the live DOM and the
+     * next change-detection pass throws `NotFoundError` on insertBefore.
+     */
+    clearAll(): void;
+    /**
+     * Clear all messages
+     * @deprecated Use clearAll() to also remove DOM bubbles
+     */
+    clearMessages(): void;
+    /**
+     * Replace the entire message list in one shot. Used when switching
+     * conversations: clears existing repo + DOM, then appends each message.
+     *
+     * In framework-managed mode the framework re-renders the bubble DOM
+     * itself; we only update the internal repo (used by aparte-client to
+     * build chat history).
+     */
+    setMessages(messages: AparteMessage[]): void;
+    /**
+     * Scroll to bottom of viewport
+     */
+    scrollToBottom(): void;
+    /**
+     * Reset the bottom spacer to 0 height immediately and freeze it for
+     * 350 ms so the host-app layout transition (e.g. flex: 0→1 animation)
+     * does not trigger a premature recalculation with mid-animation geometry.
+     * Call before a full messages swap.
+     */
+    resetSpacer(): void;
+    /**
+     * Enable or disable auto-scroll
+     */
+    setAutoScroll(enabled: boolean): void;
+    /**
+     * Signal that a framework (e.g. Angular) manages the bubble DOM.
+     * When true, branch navigation dispatches `aparte-path-changed` without
+     * clearing/rebuilding the messages wrapper — the framework re-renders instead.
+     */
+    setFrameworkManagedDOM(managed: boolean): void;
+    private _getOrCreateMessage;
+    private _notifyBubble;
+    /**
+     * Re-render the active path: clears the messages wrapper and rebuilds bubbles
+     * for every message on the current active branch path (root → head).
+     * Calls `setSiblings(count, index)` on each bubble that has siblings, and
+     * dispatches `aparte-path-changed` so Angular wrapper can sync its signal.
+     *
+     * When `_frameworkManagedDOM` is true (set via setFrameworkManagedDOM), the DOM
+     * manipulation is skipped — only `aparte-path-changed` is dispatched so the
+     * framework can re-render from updated signal state.
+     */
+    private _reRenderActivePath;
+    private _dispatchPathChanged;
+    private _autoScroll;
+    /**
+     * Request that the next auto-scroll triggered by a DOM mutation uses
+     * smooth behaviour instead of instant. Call this just before adding a
+     * user message bubble so the viewport animates down rather than jumping.
+     * Resets automatically after the first auto-scroll fires.
+     */
+    requestSmoothScroll(): void;
+    private _render;
+    /**
+     * DOM setup for framework-managed mode. The framework (React/Vue/Svelte/
+     * Angular) renders the bubble elements as DIRECT children of the host, so we
+     * must NOT relocate them into an internal wrapper — that desyncs the
+     * framework's virtual DOM from the real DOM and throws NotFoundError on the
+     * next append. Instead the HOST itself is the scroll surface, the spacer is
+     * additive `padding-bottom` (no element), and the scroll button is a
+     * `position: sticky` TRAILING foreign child (kept last by the framework
+     * MutationObserver). A present foreign node is still a valid `insertBefore`
+     * reference for the framework — the crash came from a RELOCATED node, not a
+     * foreign one.
+     */
+    private _setupFrameworkDOM;
+    /**
+     * Keep the sticky scroll button as the last child in framework-managed mode.
+     * The framework usually inserts bubbles before its own trailing nodes (so the
+     * button stays last), but a plain `appendChild` at the very end (e.g. some
+     * Angular @for paths) can land a bubble after it — move it back. Idempotent:
+     * a no-op when already last, so it never loops the MutationObserver.
+     */
+    private _keepScrollButtonLast;
+    /** Current spacer height — a padding value (framework) or the element's height (core). */
+    private _getSpacerHeight;
+    /** Set the spacer — host padding (framework, additive to base padding) or element height (core). */
+    private _setSpacerHeight;
+    private _setupEventListeners;
+    private _setupObservers;
+    private _handleScroll;
+    private _scrollToBottom;
+    private _smoothScrollToBottom;
+    private _prefersReducedMotion;
+    /**
+     * Show/hide the scroll-to-bottom button based on the current auto-scroll state.
+     * Hidden when already at bottom (_isAutoScrollEnabled = true).
+     */
+    private _updateScrollButton;
+    /**
+     * Recalculate the bottom spacer height so the last user message is always
+     * pinned to the top of the scroll area when a response is being generated.
+     *
+     * spacer = max(0, viewportHeight - lastUserBubble.offsetHeight - lastAssistantBubble.offsetHeight)
+     *
+     * The spacer shrinks progressively as the assistant streams content, eventually
+     * reaching 0 when the combined height fills the viewport.
+     */
+    private _recalculateSpacer;
+    /**
+     * Schedule a spacer recalculation on the next animation frame.
+     * Batches multiple rapid calls (e.g. during token streaming) into one.
+     *
+     * Single-RAF intentional: both the scroll-to-bottom queued by MutationObserver
+     * and this spacer recalculation must land in the *same* frame so the browser
+     * paints exactly once — with the correct scroll position *and* the correct
+     * spacer height. A double-RAF would put the spacer shrink one frame after the
+     * scroll, causing a 1-frame layout jump during streaming.
+     */
+    private _scheduleSpacerUpdate;
+    /**
+     * Cap the number of rendered bubbles in the DOM (perf ceiling only).
+     *
+     * Drops the oldest `<aparte-chat-bubble>` elements beyond `_maxRenderedBubbles`
+     * from the DOM. It **never** touches the MessageRepository — the conversation
+     * model and its persistence snapshot stay complete (retention/eviction is a
+     * consumer/persistence concern, not the viewport's). No-op when a framework
+     * owns the DOM.
+     */
+    private _pruneRenderedBubbles;
+    private _warnMaxMessagesDeprecated;
+    private _cleanup;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'aparte-chat-viewport': AparteChatViewport;
+    }
+}
+//# sourceMappingURL=aparte-chat-viewport.d.ts.map

package/dist/components/viewport/aparte-chat-viewport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aparte-chat-viewport.d.ts","sourceRoot":"","sources":["../../../src/components/viewport/aparte-chat-viewport.ts"],"names":[],"mappings":"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"}

package/dist/components/viewport/index.d.ts

@@ -0,0 +1,2 @@
+export { AparteChatViewport } from './aparte-chat-viewport.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/viewport/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/viewport/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/config/action-provider.d.ts

@@ -0,0 +1,59 @@
+/** Zones where a custom action can appear. */
+export type AparteActionZone = 'composer' | 'bubble';
+/**
+ * A custom action button, registered once via `AparteConfig.registerAction(...)`
+ * and placed in one or more zones — the composer toolbar and/or the message
+ * (bubble) toolbar — via `zones`.
+ *
+ * Declarative and framework-agnostic: clicking it emits an `aparte-action`
+ * CustomEvent (bubbles, composed) carrying `{ actionId, zone, … }`, exactly like
+ * the built-in retry/feedback buttons — so you wire it the same way in
+ * React/Vue/Svelte/Angular and in vanilla. An optional `onClick` callback fires
+ * alongside the event for imperative convenience.
+ *
+ * @example
+ * AparteConfig.registerAction({
+ *   id: 'share', icon: '<svg>…</svg>', label: 'Share',
+ *   zones: ['bubble'], bubble: { roles: ['assistant'] },
+ * });
+ * chatEl.addEventListener('aparte-action', (e) => {
+ *   if (e.detail.actionId === 'share') share(e.detail.messageId);
+ * });
+ */
+export interface AparteAction {
+    /** Stable id — echoed as `actionId` in the `aparte-action` event. */
+    id: string;
+    /**
+     * Icon for the button:
+     * - If it starts with `<`, it is treated as raw HTML/SVG and used directly.
+     * - Otherwise it is treated as a key for `AparteConfig.getIcon()`. If the
+     *   provider doesn't have the key, falls back to `iconFallback` or `id`.
+     */
+    icon: string;
+    /** Inline SVG/HTML fallback used when the icon provider doesn't have the key. */
+    iconFallback?: string;
+    /** Accessible label (sets `aria-label` + `title`) — a locale key or a raw string. */
+    label: string;
+    /** Lower renders first among custom actions (they follow the built-ins). */
+    order?: number;
+    /** Which zones this action appears in. */
+    zones: AparteActionZone[];
+    /** Composer-toolbar placement (used when `zones` includes `'composer'`). */
+    composer?: {
+        /** Toolbar side. Default: `'left'`. */
+        position?: 'left' | 'right';
+        /**
+         * When `true`, the button is hidden from the composer toolbar.
+         * Toggle at runtime with `AparteConfig.setActionHidden(id, hidden)`.
+         */
+        hidden?: boolean;
+    };
+    /** Bubble-toolbar placement (used when `zones` includes `'bubble'`). */
+    bubble?: {
+        /** Bubble roles this action shows on. Default: both user and assistant. */
+        roles?: ('user' | 'assistant')[];
+    };
+    /** Optional imperative callback, fired alongside the `aparte-action` event. */
+    onClick?: (event: Event, context?: unknown) => void;
+}
+//# sourceMappingURL=action-provider.d.ts.map

package/dist/config/action-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action-provider.d.ts","sourceRoot":"","sources":["../../src/config/action-provider.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,MAAM,MAAM,gBAAgB,GAAG,UAAU,GAAG,QAAQ,CAAC;AAErD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,YAAY;IACzB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,qFAAqF;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,4EAA4E;IAC5E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0CAA0C;IAC1C,KAAK,EAAE,gBAAgB,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,EAAE;QACP,uCAAuC;QACvC,QAAQ,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAC5B;;;WAGG;QACH,MAAM,CAAC,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,wEAAwE;IACxE,MAAM,CAAC,EAAE;QACL,2EAA2E;QAC3E,KAAK,CAAC,EAAE,CAAC,MAAM,GAAG,WAAW,CAAC,EAAE,CAAC;KACpC,CAAC;IACF,+EAA+E;IAC/E,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;CACvD"}