@visuno/angular 0.0.0-stage → 0.1.0

package/top-pages/top-pages.component.d.ts

@@ -0,0 +1,75 @@
+import { AfterViewInit, ChangeDetectorRef, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { ReducedMotionService } from '../core/reduced-motion.service';
+import * as i0 from "@angular/core";
+/** One page row. */
+export interface TopPagesPage {
+    /** The page's path, like "/pricing". */
+    path: string;
+    /** Its name, like "Pricing". */
+    title: string;
+    /** Views over the period. */
+    views: number;
+    /** Change against the period before, in percent, like 24 or -8. */
+    change: number;
+    /** Shown when you hover the row. Defaults to the site and the path, like "visuno.dev/pricing". */
+    tip?: string;
+}
+/** How the rows are ordered. */
+export type TopPagesSort = 'views' | 'change';
+/** Internal per-row render state. */
+interface RowView {
+    page: TopPagesPage;
+    index: number;
+    at: number;
+    rank: number;
+    width: number;
+    tip: string;
+    changeText: string;
+    changeClass: string;
+    enterDelay: number;
+}
+export declare class TopPagesComponent implements AfterViewInit, OnDestroy {
+    private readonly reduced;
+    private readonly cdr;
+    private readonly host;
+    /** The page rows. */
+    pages: TopPagesPage[];
+    /** Header text. */
+    title: string;
+    /** After the total, like "last 30 days". */
+    period: string;
+    /** Put in front of each path in the row tips, like "visuno.dev". */
+    site?: string;
+    /** How the rows are ordered. Leave it out to let the switch change it. */
+    set sort(value: TopPagesSort | undefined);
+    defaultSort: TopPagesSort;
+    sortChange: EventEmitter<TopPagesSort>;
+    readonly ROW = 50;
+    readonly fmt: (n: number) => string;
+    readonly options: {
+        value: TopPagesSort;
+        label: string;
+    }[];
+    by: TopPagesSort;
+    rows: RowView[];
+    shownTotal: number;
+    knobLeft: number;
+    knobWidth: number;
+    animate: boolean;
+    private controlled;
+    private ready;
+    private max;
+    private timers;
+    private frames;
+    constructor(reduced: ReducedMotionService, cdr: ChangeDetectorRef, host: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    select(value: TopPagesSort): void;
+    private reorder;
+    private roll;
+    private placeKnob;
+    private later;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TopPagesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TopPagesComponent, "vo-top-pages", never, { "pages": { "alias": "pages"; "required": true; }; "title": { "alias": "title"; "required": false; }; "period": { "alias": "period"; "required": false; }; "site": { "alias": "site"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "defaultSort": { "alias": "defaultSort"; "required": false; }; }, { "sortChange": "sortChange"; }, never, never, true, never>;
+}
+export {};

package/trace-view/trace-view.component.d.ts

@@ -0,0 +1,95 @@
+import { EventEmitter } from '@angular/core';
+import { type VoIconName } from '../core/icon.component';
+import * as i0 from "@angular/core";
+export type SpanKind = 'agent' | 'llm' | 'tool' | 'retrieval';
+export interface TraceSpan {
+    id: string;
+    /** Like "Plan the steps" or the tool's name, "fetch_page". */
+    name: string;
+    kind: SpanKind;
+    /** When it started, in seconds from the start of the run. */
+    start: number;
+    /** How long it took, in seconds. Leave it out while it runs: its bar grows to time. */
+    duration?: number;
+    /** Tokens it used. An agent span without its own count adds up every span under it. */
+    tokens?: number;
+    /** What went in and what came out, shown when the span is opened. */
+    input?: string;
+    output?: string;
+    children?: TraceSpan[];
+}
+/** A flattened row with its nesting level and parent, for the tree guides. */
+interface Row {
+    s: TraceSpan;
+    lv: number;
+    up?: Row;
+}
+/** One guide line in the tree gutter. */
+interface Guide {
+    x: number;
+    cls: string;
+}
+/** A legend entry. */
+interface LegendItem {
+    kind: SpanKind;
+    label: string;
+    color: string;
+    count: number;
+}
+/** One agent run as an observability waterfall. */
+export declare class TraceViewComponent {
+    /** The run's name, like "Pricing research". */
+    title: string;
+    /** The run's top spans, usually one root with everything nested under it. */
+    spans: TraceSpan[];
+    /** Seconds into the run while it streams in. Leave it out once the run is over. */
+    time?: number;
+    /** Seconds the time axis covers. Defaults to the run's length, rounded up. */
+    axis?: number;
+    /** A tool call longer than this many seconds turns amber and is tagged slow. */
+    slowAfter: number;
+    /** The line under the title. */
+    status?: string;
+    /** The id of the open span. null closes the details. */
+    set selected(value: string | null | undefined);
+    defaultSelected: string | null;
+    selectedChange: EventEmitter<string | null>;
+    readonly KIND: Record<SpanKind, [string, VoIconName, string]>;
+    readonly sec: (v: number) => string;
+    readonly short: (v: number) => string;
+    readonly tokensOf: (s: TraceSpan) => number;
+    open: string | null;
+    private controlled;
+    private lastSel?;
+    private inited;
+    private ensureInit;
+    /** Every span flattened, with its level and parent row. */
+    get all(): Row[];
+    get end(): number;
+    get span(): number;
+    get now(): number;
+    get shown(): Row[];
+    get nowFrac(): number;
+    get isLive(): boolean;
+    get totalText(): string;
+    get line(): string;
+    get legend(): LegendItem[];
+    get tick(): number;
+    get labels(): number[];
+    get gridSize(): string;
+    get sel(): TraceSpan | undefined;
+    get cur(): TraceSpan | undefined;
+    took(s: TraceSpan): number;
+    isRunning(s: TraceSpan): boolean;
+    isSlow(s: TraceSpan): boolean;
+    tokenText(s: TraceSpan): string;
+    rowLabel(s: TraceSpan): string;
+    /** The tree's guides for a row: lines down from ancestors with later siblings,
+        an elbow into this row, and a line down to its own children. */
+    guides(x: Row): Guide[];
+    select(id: string | null): void;
+    onKey(e: KeyboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TraceViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TraceViewComponent, "vo-trace-view", never, { "title": { "alias": "title"; "required": false; }; "spans": { "alias": "spans"; "required": false; }; "time": { "alias": "time"; "required": false; }; "axis": { "alias": "axis"; "required": false; }; "slowAfter": { "alias": "slowAfter"; "required": false; }; "status": { "alias": "status"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "defaultSelected": { "alias": "defaultSelected"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+export {};

package/voice-capture/voice-capture.component.d.ts

@@ -0,0 +1,103 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+/** listening and paused record, review asks the person to check the words, sent and cancelled are the end. */
+export type VoiceCaptureState = 'listening' | 'paused' | 'review' | 'sent' | 'cancelled';
+/** A word the speech model was not sure about. */
+export interface HeardWord {
+    text: string;
+    /** What it might have been instead. Highlights the word and lets the person pick one. */
+    alternatives?: string[];
+}
+/** One word as it is rendered: its text, whether it is unsure, and whether a fix has been picked. */
+interface RenderWord {
+    index: number;
+    text: string;
+    alternatives: string[];
+    fixed: boolean;
+}
+export declare class VoiceCaptureComponent implements AfterViewInit, OnChanges, OnDestroy {
+    /** The words heard so far, in order. Add to the end as they arrive and each one fades in. */
+    words: Array<string | HeardWord>;
+    /** The state, or leave it out to let the buttons move it along. */
+    state?: VoiceCaptureState;
+    defaultState: VoiceCaptureState;
+    /** Seconds recorded. Leave it out to let it count while listening. */
+    seconds?: number;
+    /** The input level from 0 to 1, drawn into the wave about 20 times a second.
+        Pass a function to read the microphone on every sample without re-rendering. */
+    level: number | (() => number);
+    /** The status line. Defaults to Listening, Paused, Check what I heard, Sent or Cancelled. */
+    status?: string;
+    stateChange: EventEmitter<VoiceCaptureState>;
+    /** Emitted with the checked transcript when the person presses Done in review. */
+    send: EventEmitter<string>;
+    /** Emitted when the person picks one of a word's alternatives. */
+    fixWord: EventEmitter<{
+        index: number;
+        text: string;
+    }>;
+    /** Emitted by Record again, once the capture is sent or cancelled. */
+    recordAgain: EventEmitter<void>;
+    root: ElementRef<HTMLDivElement>;
+    waveRef: ElementRef<HTMLCanvasElement>;
+    popRef: ElementRef<HTMLDivElement>;
+    private readonly motion;
+    readonly STATUS: Record<VoiceCaptureState, string>;
+    private inner;
+    get now(): VoiceCaptureState;
+    get live(): boolean;
+    get ended(): boolean;
+    held?: number;
+    private liveHeight?;
+    private count;
+    get clockText(): string;
+    private tick?;
+    private fixes;
+    rendered: RenderWord[];
+    menuOpen: boolean;
+    menu: {
+        index: number;
+        alts: string[];
+        left: number;
+        top: number;
+    };
+    private keyOpen;
+    private inMenu;
+    private samples;
+    private raf;
+    private lastSample;
+    private cols;
+    private colsAt;
+    private drawn;
+    private ro?;
+    private onDocClick;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private buildWords;
+    private syncClock;
+    private measure;
+    private onStateFlip;
+    togglePause(): void;
+    private setState;
+    private transcript;
+    done(): void;
+    cancel(): void;
+    again(): void;
+    wordKey(index: number, e: KeyboardEvent): void;
+    show(index: number, e: Event, key: boolean): void;
+    private closeMenu;
+    private wordEl;
+    menuKey(e: KeyboardEvent): void;
+    fix(index: number, text: string): void;
+    private docClick;
+    private colours;
+    private bars;
+    private paint;
+    private still;
+    private startWave;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VoiceCaptureComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VoiceCaptureComponent, "vo-voice-capture", never, { "words": { "alias": "words"; "required": false; }; "state": { "alias": "state"; "required": false; }; "defaultState": { "alias": "defaultState"; "required": false; }; "seconds": { "alias": "seconds"; "required": false; }; "level": { "alias": "level"; "required": false; }; "status": { "alias": "status"; "required": false; }; }, { "stateChange": "stateChange"; "send": "send"; "fixWord": "fixWord"; "recordAgain": "recordAgain"; }, never, never, true, never>;
+}
+export {};

package/voice-orb/voice-orb.component.d.ts

@@ -0,0 +1,78 @@
+import { AfterViewInit, EventEmitter, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+/** idle (not started), listening, thinking, speaking (the agent) or ended. */
+export type VoiceState = 'idle' | 'listening' | 'thinking' | 'speaking' | 'ended';
+/** What was said last and who said it. A new id (or speaker) starts a new line. */
+export interface VoiceCaption {
+    speaker: string;
+    text: string;
+    id?: string;
+}
+/** Labels, so every bit of text can be localised. */
+export interface VoiceOrbLabels {
+    ready?: string;
+    listening?: string;
+    thinking?: string;
+    speaking?: string;
+    muted?: string;
+    ended?: string;
+    start?: string;
+    end?: string;
+    mute?: string;
+    unmute?: string;
+    mutedNotice?: string;
+    endedTitle?: string;
+    restart?: string;
+}
+export declare class VoiceOrbComponent implements OnChanges, AfterViewInit, OnDestroy {
+    /** idle, listening, thinking, speaking or ended. */
+    state: VoiceState;
+    /** How loud whoever is talking is, 0 to 1. The orb swells with it. */
+    level: number;
+    /** Your microphone is off. Listening shows as Muted, the mute button is pressed. */
+    muted: boolean;
+    /** Shows "You're muted" with an Unmute button, for when someone talks while muted. */
+    mutedNotice: boolean;
+    /** What was said last and who said it; each word fades in as it arrives. */
+    caption: VoiceCaption | null;
+    /** Shown before anything is said, like "Talk to the agent about Pricing v4". */
+    hint: string;
+    /** Seconds since the chat started, shown top right. */
+    elapsed: number;
+    /** The quiet line under "Voice chat ended". Defaults to the length and "Transcript saved". */
+    endedDetail?: string;
+    labels: VoiceOrbLabels;
+    className: string;
+    mutedChange: EventEmitter<boolean>;
+    start: EventEmitter<void>;
+    end: EventEmitter<void>;
+    /** Start again, from the row that shows once the chat has ended. */
+    restart: EventEmitter<void>;
+    private glRef?;
+    private readonly motion;
+    L: Required<VoiceOrbLabels>;
+    get mode(): string;
+    get status(): string;
+    get on(): boolean;
+    get noticeOpen(): boolean;
+    get lv(): string;
+    get defaultDetail(): string;
+    readonly fmt: (s: number) => string;
+    words(text: string): string[];
+    emitMuted(next: boolean): void;
+    private shader;
+    private raf;
+    private flow;
+    private last;
+    private cols;
+    private colsAt;
+    private io?;
+    private seen;
+    private started;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private draw;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VoiceOrbComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VoiceOrbComponent, "vo-voice-orb", never, { "state": { "alias": "state"; "required": false; }; "level": { "alias": "level"; "required": false; }; "muted": { "alias": "muted"; "required": false; }; "mutedNotice": { "alias": "mutedNotice"; "required": false; }; "caption": { "alias": "caption"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "elapsed": { "alias": "elapsed"; "required": false; }; "endedDetail": { "alias": "endedDetail"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "className": { "alias": "className"; "required": false; }; }, { "mutedChange": "mutedChange"; "start": "start"; "end": "end"; "restart": "restart"; }, never, never, true, never>;
+}

package/web-search/web-search.component.d.ts

@@ -0,0 +1,77 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import * as i0 from "@angular/core";
+/** One page the agent opened for a query. */
+export interface WebPage {
+    title: string;
+    /** Like "stripe.com". */
+    domain: string;
+    /** Like "Oct 2026". */
+    date?: string;
+    /** reading while the agent opens it; the skipped ones say why. */
+    status: 'reading' | 'read' | 'skimmed' | 'paywall' | 'blocked' | 'timeout';
+    /** The number the answer cites it by, as [1]. */
+    cite?: number;
+}
+/** One search the agent made. */
+export interface WebQuery {
+    key: string;
+    query: string;
+    /** searching shimmers; done shows the count and the time. */
+    status: 'searching' | 'done';
+    /** How many results came back; 0 says No results. */
+    results?: number;
+    /** Like "0.9s". */
+    time?: string;
+    /** This query asks the one before it again in other words. */
+    rewritten?: boolean;
+    pages?: WebPage[];
+}
+/** One flattened page with its query key, for citations and marks. */
+interface FlatPage extends WebPage {
+    q: string;
+}
+/** One piece of the answer: plain text or a citation button. */
+interface AnswerPart {
+    text?: string;
+    cite?: number;
+}
+/** The agent's web searches as a trail, with an answer whose citations light their pages. */
+export declare class WebSearchComponent implements OnChanges {
+    queries: WebQuery[];
+    /** True once searching and reading are over: the trail folds to its summary. */
+    done: boolean;
+    /** The answer, with sources cited as [1], [2]. Each number points at the page with that cite. */
+    answer?: string;
+    /** Whether the trail is open. Left out, it folds once done turns true. */
+    set open(value: boolean | undefined);
+    /** Without the panel, for a chat stream. */
+    bare: boolean;
+    openChange: EventEmitter<boolean>;
+    readonly STATUS: Record<"reading" | "read" | "skimmed" | "paywall" | "blocked" | "timeout", [string, string]>;
+    hot: number | null;
+    said: string;
+    private controlled;
+    private inner;
+    private qOpen;
+    private lastSaid;
+    get isOpen(): boolean;
+    get flatPages(): FlatPage[];
+    get sites(): string[];
+    get marks(): string[];
+    get line(): string;
+    get hotPage(): FlatPage | undefined;
+    get answerParts(): AnswerPart[];
+    hasPages(q: WebQuery): boolean;
+    isQOpen(q: WebQuery): boolean;
+    isSkip(p: WebPage): boolean;
+    qLabel(q: WebQuery): string | null;
+    pageLabel(p: WebPage): string;
+    citeLabel(n: number | undefined): string;
+    toggle(): void;
+    toggleQ(q: WebQuery): void;
+    private setOpen;
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WebSearchComponent, "vo-web-search", never, { "queries": { "alias": "queries"; "required": false; }; "done": { "alias": "done"; "required": false; }; "answer": { "alias": "answer"; "required": false; }; "open": { "alias": "open"; "required": false; }; "bare": { "alias": "bare"; "required": false; }; }, { "openChange": "openChange"; }, never, never, true, never>;
+}
+export {};