Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
import { Panel } from './Panel';
import { escapeHtml } from '@/utils/sanitize';
import { debounce } from '@/utils/index';
// --- Types ---
type NoteStyle = 'sticky' | 'lined' | 'markdown' | 'checklist' | 'kanban' | 'cornell';
interface StickyNote {
id: string;
text: string;
color: number;
}
interface KanbanCard {
id: string;
text: string;
createdAt: string;
}
interface ChecklistItem {
id: string;
text: string;
checked: boolean;
}
interface CornellData {
cues: string;
notes: string;
summary: string;
}
interface NotesData {
sticky: StickyNote[];
lined: string;
markdown: string;
checklist: ChecklistItem[];
kanban: { todo: KanbanCard[]; inProgress: KanbanCard[]; done: KanbanCard[] };
cornell: CornellData;
}
const STORAGE_KEY = 'hq-notes-data';
const MAX_ITEMS = 50;
const SAVE_DEBOUNCE_MS = 400;
const STICKY_COLORS = ['#fbbf24', '#f472b6', '#60a5fa', '#34d399', '#a78bfa', '#fb923c'];
const STYLE_LABELS: { key: NoteStyle; label: string }[] = [
{ key: 'sticky', label: 'Sticky' },
{ key: 'lined', label: 'Lined' },
{ key: 'markdown', label: 'Markdown' },
{ key: 'checklist', label: 'Checklist' },
{ key: 'kanban', label: 'Kanban' },
{ key: 'cornell', label: 'Cornell' },
];
/** Generate a collision-resistant unique ID (timestamp + 12 chars random). */
function uid(): string {
return Date.now().toString(36) + Math.random().toString(36).slice(2, 10) + Math.random().toString(36).slice(2, 6);
}
function isObject(v: unknown): v is Record<string, unknown> {
return typeof v === 'object' && v !== null && !Array.isArray(v);
}
function isString(v: unknown): v is string {
return typeof v === 'string';
}
function defaultData(): NotesData {
return {
sticky: [],
lined: '',
markdown: '',
checklist: [],
kanban: { todo: [], inProgress: [], done: [] },
cornell: { cues: '', notes: '', summary: '' },
};
}
/** Validate and sanitize loaded data - never trust localStorage blindly. */
function validateData(raw: unknown): NotesData {
const defaults = defaultData();
if (!isObject(raw)) return defaults;
const data = raw as Record<string, unknown>;
// Validate sticky notes
const sticky = Array.isArray(data.sticky)
? (data.sticky as unknown[]).filter((n): n is StickyNote =>
isObject(n) && isString((n as Record<string, unknown>).id) && isString((n as Record<string, unknown>).text) && typeof (n as Record<string, unknown>).color === 'number'
).slice(0, MAX_ITEMS)
: defaults.sticky;
// Validate checklist
const checklist = Array.isArray(data.checklist)
? (data.checklist as unknown[]).filter((c): c is ChecklistItem =>
isObject(c) && isString((c as Record<string, unknown>).id) && isString((c as Record<string, unknown>).text) && typeof (c as Record<string, unknown>).checked === 'boolean'
).slice(0, MAX_ITEMS)
: defaults.checklist;
// Validate kanban
const validateCards = (arr: unknown): KanbanCard[] =>
Array.isArray(arr)
? (arr as unknown[]).filter((c): c is KanbanCard =>
isObject(c) && isString((c as Record<string, unknown>).id) && isString((c as Record<string, unknown>).text) && isString((c as Record<string, unknown>).createdAt)
).slice(0, MAX_ITEMS)
: [];
const kanbanRaw = isObject(data.kanban) ? data.kanban as Record<string, unknown> : {};
const kanban = {
todo: validateCards(kanbanRaw.todo),
inProgress: validateCards(kanbanRaw.inProgress),
done: validateCards(kanbanRaw.done),
};
// Validate cornell
const cornellRaw = isObject(data.cornell) ? data.cornell as Record<string, unknown> : {};
const cornell: CornellData = {
cues: isString(cornellRaw.cues) ? String(cornellRaw.cues) : '',
notes: isString(cornellRaw.notes) ? String(cornellRaw.notes) : '',
summary: isString(cornellRaw.summary) ? String(cornellRaw.summary) : '',
};
return {
sticky,
lined: isString(data.lined) ? String(data.lined) : defaults.lined,
markdown: isString(data.markdown) ? String(data.markdown) : defaults.markdown,
checklist,
kanban,
cornell,
};
}
export class NotesPanel extends Panel {
private data: NotesData = defaultData();
private style: NoteStyle = 'sticky';
private mdPreview = false;
private readonly debouncedSave: () => void;
private boundStorageHandler: ((e: StorageEvent) => void) | null = null;
constructor() {
super({ id: 'notes', title: 'Notes', className: 'notes-panel', showCount: true });
this.debouncedSave = debounce(() => this.persistNow(), SAVE_DEBOUNCE_MS);
this.load();
this.render();
this.listenCrossTab();
}
// --- Persistence ---
private load(): void {
try {
const raw = localStorage.getItem(STORAGE_KEY);
if (raw) this.data = validateData(JSON.parse(raw));
} catch { /* ignore corrupt data - fall back to defaults */ }
}
/** Flush data to localStorage immediately (called by debounced wrapper). */
private persistNow(): void {
localStorage.setItem(STORAGE_KEY, JSON.stringify(this.data));
}
/** Queue a debounced save - safe to call on every keystroke. */
private save(): void {
this.debouncedSave();
}
/** Flush pending saves immediately (used before destroy). */
private flushSave(): void {
this.persistNow();
}
/** Listen for cross-tab localStorage changes. */
private listenCrossTab(): void {
this.boundStorageHandler = (e: StorageEvent) => {
if (e.key === STORAGE_KEY && e.newValue) {
try {
this.data = validateData(JSON.parse(e.newValue));
this.render();
} catch { /* ignore */ }
}
};
window.addEventListener('storage', this.boundStorageHandler);
}
private getItemCount(): number {
switch (this.style) {
case 'sticky': return this.data.sticky.length;
case 'checklist': return this.data.checklist.length;
case 'kanban': return this.data.kanban.todo.length + this.data.kanban.inProgress.length + this.data.kanban.done.length;
default: return 0;
}
}
// --- Main Render ---
private render(): void {
this.setCount(this.getItemCount());
const tabs = STYLE_LABELS.map(s =>
`<button class="notes-tab ${this.style === s.key ? 'active' : ''}" data-style="${s.key}">${s.label}</button>`
).join('');
let body = '';
switch (this.style) {
case 'sticky': body = this.renderSticky(); break;
case 'lined': body = this.renderLined(); break;
case 'markdown': body = this.renderMarkdown(); break;
case 'checklist': body = this.renderChecklist(); break;
case 'kanban': body = this.renderKanban(); break;
case 'cornell': body = this.renderCornell(); break;
}
this.setContent(`
<div class="notes-container">
<div class="notes-tabs">${tabs}</div>
<div class="notes-body">${body}</div>
</div>
`);
this.bindTabs();
this.bindView();
}
private bindTabs(): void {
this.content.querySelectorAll('.notes-tab').forEach(btn => {
btn.addEventListener('click', () => {
this.style = (btn as HTMLElement).dataset.style as NoteStyle;
this.render();
});
});
}
// --- Sticky Notes ---
private renderSticky(): string {
const notes = this.data.sticky.map(n => {
const bg = STICKY_COLORS[n.color % STICKY_COLORS.length];
return `<div class="notes-sticky" data-id="${n.id}" style="background:${bg}">
<textarea class="notes-sticky-text" data-id="${n.id}">${escapeHtml(n.text)}</textarea>
<button class="notes-sticky-del" data-id="${n.id}" title="Delete">×</button>
</div>`;
}).join('');
return `<div class="notes-sticky-grid">${notes}
<button class="notes-sticky-add" title="Add sticky note">+ Add Note</button>
</div>`;
}
// --- Lined Notepad ---
private renderLined(): string {
return `<div class="notes-lined-wrap">
<textarea class="notes-lined-textarea" placeholder="Start typing…">${escapeHtml(this.data.lined)}</textarea>
</div>`;
}
// --- Markdown ---
private renderMarkdown(): string {
const toggle = `<div class="notes-md-toggle">
<button class="notes-tab ${!this.mdPreview ? 'active' : ''}" data-md="edit">Edit</button>
<button class="notes-tab ${this.mdPreview ? 'active' : ''}" data-md="preview">Preview</button>
</div>`;
if (this.mdPreview) {
return toggle + `<div class="notes-md-preview">${this.renderMarkdownText(this.data.markdown)}</div>`;
}
return toggle + `<textarea class="notes-md-editor" placeholder="Write markdown…">${escapeHtml(this.data.markdown)}</textarea>`;
}
private renderMarkdownText(text: string): string {
if (!text) return '<span class="notes-empty">Nothing to preview</span>';
let html = escapeHtml(text);
// Code blocks (must come before inline patterns)
html = html.replace(/```([\s\S]*?)```/g, '<pre class="notes-code-block">$1</pre>');
// Inline code
html = html.replace(/`([^`]+)`/g, '<code>$1</code>');
// Headers
html = html.replace(/^### (.+)$/gm, '<h4>$1</h4>');
html = html.replace(/^## (.+)$/gm, '<h3>$1</h3>');
html = html.replace(/^# (.+)$/gm, '<h2>$1</h2>');
// Bold & italic
html = html.replace(/\*\*(.+?)\*\*/g, '<strong>$1</strong>');
html = html.replace(/\*(.+?)\*/g, '<em>$1</em>');
// Lists - group consecutive <li> items into <ul> blocks correctly
html = html.replace(/^- (.+)$/gm, '<li>$1</li>');
html = html.replace(/((?:<li>.*<\/li>\n?)+)/g, '<ul>$1</ul>');
// Line breaks (but not inside <pre> blocks or already-converted tags)
html = html.replace(/\n/g, '<br>');
return html;
}
// --- Checklist ---
private renderChecklist(): string {
const checked = this.data.checklist.filter(c => c.checked).length;
const total = this.data.checklist.length;
const pct = total > 0 ? Math.round((checked / total) * 100) : 0;
const items = this.data.checklist.map((item, i) => `
<div class="notes-check-item ${item.checked ? 'checked' : ''}" data-id="${item.id}">
<button class="notes-check-box" data-action="toggle" data-id="${item.id}">${item.checked ? '☑' : '☐'}</button>
<span class="notes-check-text">${escapeHtml(item.text)}</span>
<div class="notes-check-actions">
${i > 0 ? `<button class="notes-check-btn" data-action="up" data-id="${item.id}" title="Move up">↑</button>` : ''}
${i < this.data.checklist.length - 1 ? `<button class="notes-check-btn" data-action="down" data-id="${item.id}" title="Move down">↓</button>` : ''}
<button class="notes-check-btn del" data-action="del" data-id="${item.id}" title="Delete">×</button>
</div>
</div>
`).join('');
return `<div class="notes-checklist">
<div class="notes-check-progress">
<div class="notes-check-bar"><div class="notes-check-fill" style="width:${pct}%"></div></div>
<span class="notes-check-count">${checked}/${total}</span>
</div>
<div class="notes-check-input-row">
<input class="notes-check-input" type="text" placeholder="Add item…" maxlength="200" />
<button class="notes-check-add">+</button>
</div>
${items}
</div>`;
}
// --- Kanban ---
private renderKanban(): string {
const cols: { key: 'todo' | 'inProgress' | 'done'; label: string }[] = [
{ key: 'todo', label: 'To Do' },
{ key: 'inProgress', label: 'In Progress' },
{ key: 'done', label: 'Done' },
];
return `<div class="notes-kanban">${cols.map(col => `
<div class="notes-kanban-col" data-col="${col.key}">
<div class="notes-kanban-header">${col.label} <span class="notes-kanban-count">${this.data.kanban[col.key].length}</span></div>
<div class="notes-kanban-cards">
${this.data.kanban[col.key].map(card => `
<div class="notes-kanban-card" data-id="${card.id}" data-col="${col.key}">
<div class="notes-kanban-card-text">${escapeHtml(card.text)}</div>
<div class="notes-kanban-card-footer">
<span class="notes-kanban-card-time">${new Date(card.createdAt).toLocaleDateString('en-US', { month: 'short', day: 'numeric' })}</span>
<div class="notes-kanban-card-actions">
${col.key !== 'todo' ? `<button class="notes-kanban-btn" data-action="left" data-id="${card.id}" data-col="${col.key}" title="Move left">←</button>` : ''}
${col.key !== 'done' ? `<button class="notes-kanban-btn" data-action="right" data-id="${card.id}" data-col="${col.key}" title="Move right">→</button>` : ''}
<button class="notes-kanban-btn del" data-action="del" data-id="${card.id}" data-col="${col.key}" title="Delete">×</button>
</div>
</div>
</div>
`).join('')}
</div>
<div class="notes-kanban-add-row">
<input class="notes-kanban-input" data-col="${col.key}" placeholder="Add card…" maxlength="200" />
<button class="notes-kanban-add-btn" data-col="${col.key}">+</button>
</div>
</div>
`).join('')}</div>`;
}
// --- Cornell ---
private renderCornell(): string {
return `<div class="notes-cornell">
<div class="notes-cornell-top">
<div class="notes-cornell-cues">
<div class="notes-cornell-label">Cues / Questions</div>
<textarea class="notes-cornell-area" data-field="cues" placeholder="Key questions, cues…">${escapeHtml(this.data.cornell.cues)}</textarea>
</div>
<div class="notes-cornell-notes">
<div class="notes-cornell-label">Notes</div>
<textarea class="notes-cornell-area" data-field="notes" placeholder="Detailed notes…">${escapeHtml(this.data.cornell.notes)}</textarea>
</div>
</div>
<div class="notes-cornell-summary">
<div class="notes-cornell-label">Summary</div>
<textarea class="notes-cornell-area" data-field="summary" placeholder="Summary…">${escapeHtml(this.data.cornell.summary)}</textarea>
</div>
</div>`;
}
// --- Event Binding per View ---
private bindView(): void {
switch (this.style) {
case 'sticky': this.bindSticky(); break;
case 'lined': this.bindLined(); break;
case 'markdown': this.bindMarkdown(); break;
case 'checklist': this.bindChecklist(); break;
case 'kanban': this.bindKanban(); break;
case 'cornell': this.bindCornell(); break;
}
}
private bindSticky(): void {
// Add note
this.content.querySelector('.notes-sticky-add')?.addEventListener('click', () => {
if (this.data.sticky.length >= MAX_ITEMS) return;
this.data.sticky.push({ id: uid(), text: '', color: this.data.sticky.length % STICKY_COLORS.length });
this.save();
this.render();
});
// Delete
this.content.querySelectorAll('.notes-sticky-del').forEach(btn => {
btn.addEventListener('click', () => {
const id = (btn as HTMLElement).dataset.id!;
this.data.sticky = this.data.sticky.filter(n => n.id !== id);
this.save();
this.render();
});
});
// Edit text
this.content.querySelectorAll<HTMLTextAreaElement>('.notes-sticky-text').forEach(ta => {
ta.addEventListener('input', () => {
const note = this.data.sticky.find(n => n.id === ta.dataset.id);
if (note) { note.text = ta.value; this.save(); }
});
});
}
private bindLined(): void {
const ta = this.content.querySelector<HTMLTextAreaElement>('.notes-lined-textarea');
ta?.addEventListener('input', () => {
this.data.lined = ta.value;
this.save();
});
}
private bindMarkdown(): void {
// Toggle
this.content.querySelectorAll('[data-md]').forEach(btn => {
btn.addEventListener('click', () => {
this.mdPreview = (btn as HTMLElement).dataset.md === 'preview';
this.render();
});
});
// Editor
const ta = this.content.querySelector<HTMLTextAreaElement>('.notes-md-editor');
ta?.addEventListener('input', () => {
this.data.markdown = ta.value;
this.save();
});
}
private bindChecklist(): void {
const input = this.content.querySelector<HTMLInputElement>('.notes-check-input');
const addBtn = this.content.querySelector('.notes-check-add');
const addItem = () => {
if (!input || !input.value.trim() || this.data.checklist.length >= MAX_ITEMS) return;
this.data.checklist.push({ id: uid(), text: input.value.trim(), checked: false });
this.save();
this.render();
};
addBtn?.addEventListener('click', addItem);
input?.addEventListener('keydown', e => { if (e.key === 'Enter') addItem(); });
this.content.querySelectorAll('.notes-check-btn, .notes-check-box').forEach(btn => {
btn.addEventListener('click', () => {
const el = btn as HTMLElement;
const id = el.dataset.id!;
const action = el.dataset.action!;
const idx = this.data.checklist.findIndex(c => c.id === id);
if (idx < 0) return;
const item = this.data.checklist[idx];
if (!item) return;
if (action === 'toggle') {
item.checked = !item.checked;
} else if (action === 'del') {
this.data.checklist.splice(idx, 1);
} else if (action === 'up' && idx > 0) {
const prev = this.data.checklist[idx - 1];
if (prev) { this.data.checklist[idx - 1] = item; this.data.checklist[idx] = prev; }
} else if (action === 'down' && idx < this.data.checklist.length - 1) {
const next = this.data.checklist[idx + 1];
if (next) { this.data.checklist[idx] = next; this.data.checklist[idx + 1] = item; }
}
this.save();
this.render();
});
});
}
private bindKanban(): void {
const colOrder: ('todo' | 'inProgress' | 'done')[] = ['todo', 'inProgress', 'done'];
// Add card
this.content.querySelectorAll('.notes-kanban-add-btn').forEach(btn => {
btn.addEventListener('click', () => {
const col = (btn as HTMLElement).dataset.col as 'todo' | 'inProgress' | 'done';
const input = this.content.querySelector<HTMLInputElement>(`.notes-kanban-input[data-col="${col}"]`);
if (!input || !input.value.trim()) return;
const total = this.data.kanban.todo.length + this.data.kanban.inProgress.length + this.data.kanban.done.length;
if (total >= MAX_ITEMS) return;
this.data.kanban[col].push({ id: uid(), text: input.value.trim(), createdAt: new Date().toISOString() });
this.save();
this.render();
});
});
// Card actions
this.content.querySelectorAll('.notes-kanban-btn').forEach(btn => {
btn.addEventListener('click', () => {
const el = btn as HTMLElement;
const id = el.dataset.id!;
const col = el.dataset.col as 'todo' | 'inProgress' | 'done';
const action = el.dataset.action!;
if (action === 'del') {
this.data.kanban[col] = this.data.kanban[col].filter(c => c.id !== id);
} else {
const ci = colOrder.indexOf(col);
const targetCol = action === 'left' ? colOrder[ci - 1] : colOrder[ci + 1];
if (!targetCol) return;
const card = this.data.kanban[col].find(c => c.id === id);
if (!card) return;
this.data.kanban[col] = this.data.kanban[col].filter(c => c.id !== id);
this.data.kanban[targetCol].push(card);
}
this.save();
this.render();
});
});
// Enter to add
this.content.querySelectorAll<HTMLInputElement>('.notes-kanban-input').forEach(input => {
input.addEventListener('keydown', e => {
if (e.key === 'Enter') {
const col = input.dataset.col as 'todo' | 'inProgress' | 'done';
this.content.querySelector<HTMLButtonElement>(`.notes-kanban-add-btn[data-col="${col}"]`)?.click();
}
});
});
}
private bindCornell(): void {
this.content.querySelectorAll<HTMLTextAreaElement>('.notes-cornell-area').forEach(ta => {
ta.addEventListener('input', () => {
const field = ta.dataset.field as 'cues' | 'notes' | 'summary';
this.data.cornell[field] = ta.value;
this.save();
});
});
}
public override destroy(): void {
this.flushSave();
if (this.boundStorageHandler) {
window.removeEventListener('storage', this.boundStorageHandler);
this.boundStorageHandler = null;
}
super.destroy();
}
public async update(): Promise<void> {
// Offline-only - no external data
}
}