@signal9/era-ui 12.1.2 → 13.0.0

package/dist/apps/notes/tree.js

@@ -1,185 +0,0 @@
-/**
- * Notes tree index — a hierarchical table of contents built by walking a
- * TipTap document's heading structure.
- *
- * This is the retrieval half of the app. Instead of embedding notes and
- * hoping vector similarity lands on the right paragraph, a model is handed
- * `treeToText(tree)` as a table of contents and reasons about which section to
- * open — then `extractSection()` returns just that slice, structure intact
- * (PageIndex-style reasoning-based retrieval).
- *
- * Nothing here touches the editor or the DOM: it operates on stored documents,
- * so it is equally usable from a tool handler, a worker, or a build step.
- */
-import { textContent, tiptapToMarkdown } from './markdown.js';
-function countWords(text) {
-    return text.trim().split(/\s+/).filter(Boolean).length;
-}
-/** Build a tree for one note's document. */
-export function buildNoteTree(noteId, title, doc) {
-    const root = { title, noteId, level: 1, wordCount: 0, children: [] };
-    if (!doc.content || doc.content.length === 0)
-        return root;
-    const stack = [root];
-    let currentText = '';
-    for (const node of doc.content) {
-        if (node.type === 'heading' && node.attrs?.level) {
-            // Text seen since the last heading belongs to the section we're leaving.
-            if (currentText.trim()) {
-                stack[stack.length - 1].wordCount += countWords(currentText);
-                currentText = '';
-            }
-            const headingLevel = node.attrs.level;
-            const treeLevel = headingLevel + 1; // note=1, H1=2, H2=3, H3=4
-            const headingNode = {
-                title: textContent(node),
-                headingId: node.attrs?.id ?? undefined,
-                level: treeLevel,
-                wordCount: 0,
-                children: []
-            };
-            // The parent is the deepest node still shallower than this heading.
-            while (stack.length > 1 && stack[stack.length - 1].level >= treeLevel) {
-                stack.pop();
-            }
-            stack[stack.length - 1].children.push(headingNode);
-            stack.push(headingNode);
-        }
-        else {
-            currentText += textContent(node) + ' ';
-        }
-    }
-    if (currentText.trim()) {
-        stack[stack.length - 1].wordCount += countWords(currentText);
-    }
-    // A note with no headings at all is one flat section.
-    if (root.children.length === 0 && root.wordCount === 0) {
-        root.wordCount = countWords(doc.content.map(textContent).join(' '));
-    }
-    return root;
-}
-/** Combine every note into one index tree. */
-export function buildGlobalTree(notes) {
-    return {
-        title: 'Notes Index',
-        level: 0,
-        wordCount: 0,
-        children: notes.map((n) => buildNoteTree(n.id, n.title, n.content))
-    };
-}
-/** Node count below (and including) this node. */
-export function countNodes(node) {
-    return 1 + node.children.reduce((sum, c) => sum + countNodes(c), 0);
-}
-/** Total words in this subtree. */
-export function totalWords(node) {
-    return node.wordCount + node.children.reduce((sum, c) => sum + totalWords(c), 0);
-}
-/**
- * Render the tree as YAML-shaped key/value text for a model to read.
- *
- * YAML-style indented pairs beat JSON on nested data in the 2025 retrieval
- * benchmarks, and the labelled fields (`id`, `hid`) are copy-pasteable straight
- * back into a `get(id)` / `extractSection(noteId, headingId)` call, which is
- * the whole point of handing over a TOC.
- */
-export function treeToText(tree) {
-    if (tree.children.length === 0)
-        return '(no notes)';
-    const blocks = [];
-    for (const note of tree.children) {
-        const noteWords = totalWords(note);
-        const lines = [
-            `- title: ${note.title || 'Untitled'}`,
-            `  id: ${note.noteId ?? '?'}`,
-            `  words: ${noteWords}`
-        ];
-        if (note.children.length > 0) {
-            lines.push('  sections:');
-            renderSections(note.children, lines, 2);
-        }
-        blocks.push(lines.join('\n'));
-    }
-    return blocks.join('\n');
-}
-function renderSections(nodes, lines, depth) {
-    const indent = '  '.repeat(depth);
-    for (const node of nodes) {
-        const shortId = node.headingId ? node.headingId.slice(0, 8) : '';
-        lines.push(`${indent}- title: ${node.title || 'Untitled'}`);
-        if (shortId)
-            lines.push(`${indent}  hid: ${shortId}`);
-        if (node.wordCount > 0)
-            lines.push(`${indent}  words: ${node.wordCount}`);
-        if (node.children.length > 0) {
-            lines.push(`${indent}  sections:`);
-            renderSections(node.children, lines, depth + 1);
-        }
-    }
-}
-function isHeading(node) {
-    return node.type === 'heading' && typeof node.attrs?.level === 'number';
-}
-function updateBreadcrumb(stack, title, level) {
-    while (stack.length > 1 && stack[stack.length - 1].level >= level) {
-        stack.pop();
-    }
-    stack.push({ title, level });
-}
-/**
- * The raw nodes of one section: everything between the target heading and the
- * next heading of the same or a higher level, plus the breadcrumb that led to
- * it. Callers pick their own serialisation.
- */
-export function extractSectionNodes(noteTitle, doc, targetHeadingId) {
-    if (!doc.content)
-        return null;
-    const headingStack = [{ title: noteTitle, level: 0 }];
-    let startIdx = -1;
-    let targetLevel = 0;
-    for (let i = 0; i < doc.content.length; i++) {
-        const node = doc.content[i];
-        if (!isHeading(node))
-            continue;
-        updateBreadcrumb(headingStack, textContent(node), node.attrs.level);
-        const headingId = node.attrs?.id;
-        if (!headingId)
-            continue;
-        // `treeToText` emits 8-char prefixes, so accept a prefix as well as the
-        // full id — otherwise a model copying from the TOC never matches.
-        if (headingId === targetHeadingId || headingId.startsWith(targetHeadingId)) {
-            startIdx = i + 1;
-            targetLevel = node.attrs.level;
-            break;
-        }
-    }
-    if (startIdx < 0)
-        return null;
-    const headingPath = headingStack.map((h) => h.title).join(' > ');
-    const nodes = [];
-    for (let i = startIdx; i < doc.content.length; i++) {
-        const node = doc.content[i];
-        if (isHeading(node) && node.attrs.level <= targetLevel)
-            break;
-        nodes.push(node);
-    }
-    return { headingPath, nodes };
-}
-/**
- * One section, serialised to markdown.
- *
- * Markdown rather than flattened text on purpose: plain-text extraction garbles
- * lists, tables, and code blocks, which is exactly the structure a model needs
- * to answer from a retrieved section.
- */
-export function extractSection(noteTitle, doc, targetHeadingId) {
-    const section = extractSectionNodes(noteTitle, doc, targetHeadingId);
-    if (!section)
-        return null;
-    const content = tiptapToMarkdown({ type: 'doc', content: section.nodes }).trim();
-    return {
-        headingPath: section.headingPath,
-        content,
-        wordCount: countWords(content)
-    };
-}

package/dist/apps/notes/types.d.ts

@@ -1,49 +0,0 @@
-/**
- * The Notes document model.
- *
- * TipTap's own `JSONContent` is deliberately loose (every field optional), so
- * the app carries its own narrowed shapes: a `doc` always has `content`, and a
- * `Note` always has the fields the list and the editor read. Nothing here
- * imports from `@tiptap/*` — the model is the persistence contract, and a
- * consumer storing notes server-side should be able to type its API against it
- * without pulling the editor in.
- */
-export interface TiptapMark {
-    type: string;
-    attrs?: Record<string, unknown>;
-}
-export interface TiptapNode {
-    type: string;
-    attrs?: Record<string, unknown>;
-    marks?: TiptapMark[];
-    content?: TiptapNode[];
-    text?: string;
-}
-export interface TiptapDocument {
-    type: 'doc';
-    content: TiptapNode[];
-}
-export interface Note {
-    id: string;
-    title: string;
-    /** A single emoji/character shown in the list, or `null` for the default glyph. */
-    icon: string | null;
-    content: TiptapDocument;
-    /**
-     * Flattened text of `content`, refreshed on every write. Kept denormalised
-     * so filtering the list never has to walk every document's AST.
-     */
-    plainText: string;
-    pinned: boolean;
-    /** Epoch milliseconds — JSON-safe, so a note survives a `structuredClone` or a
-     *  `JSON.stringify` round-trip through storage without a revive step. */
-    createdAt: number;
-    updatedAt: number;
-}
-/** The projection the sidebar list renders — no document body. */
-export type NoteListItem = Pick<Note, 'id' | 'title' | 'icon' | 'pinned' | 'updatedAt'>;
-/** Fields a caller may hand to `NotesStore.create()`. */
-export type NoteInit = Partial<Pick<Note, 'title' | 'icon' | 'content' | 'pinned'>>;
-/** Fields `NotesStore.update()` accepts. */
-export type NotePatch = Partial<Pick<Note, 'title' | 'icon' | 'content' | 'pinned'>>;
-export declare const EMPTY_DOC: TiptapDocument;

package/dist/apps/notes/types.js

@@ -1,11 +0,0 @@
-/**
- * The Notes document model.
- *
- * TipTap's own `JSONContent` is deliberately loose (every field optional), so
- * the app carries its own narrowed shapes: a `doc` always has `content`, and a
- * `Note` always has the fields the list and the editor read. Nothing here
- * imports from `@tiptap/*` — the model is the persistence contract, and a
- * consumer storing notes server-side should be able to type its API against it
- * without pulling the editor in.
- */
-export const EMPTY_DOC = { type: 'doc', content: [{ type: 'paragraph' }] };

package/dist/os/layers.d.ts

@@ -1,23 +0,0 @@
-/**
- * The layer contract for the OS shell.
- *
- * The hard rule desktop UIs get wrong: a pane's z-index must NEVER be able to
- * cover a menu, toast, or the taskbar's command dropdown. We guarantee that structurally rather
- * than by juggling numbers — the `Desktop` surface is an isolated stacking
- * context (`isolate`), so every pane's z-index (1..N, handed out by the
- * PaneManager) is *contained* within it. OS chrome and portalled overlays
- * render OUTSIDE that context, at the document root, so they always paint above
- * the entire desktop no matter how high a pane's z climbs.
- *
- * These are the root-level tiers (all above the isolated desktop). bits-ui
- * dialogs/menus/tooltips portal to <body> at z-50; the tiers below are chosen
- * around that: chrome sits under menus, transient system UI sits over them.
- */
-export declare const LAYER: {
-    /** Taskbar / dock — chrome, below menus so a taskbar dropdown (z-50) opens over it. */
-    readonly taskbar: "z-30";
-    /** Slide-over notification center — chrome, same band as the taskbar it hangs off. */
-    readonly notificationCenter: "z-40";
-    /** Toasts — above bits-ui overlays (z-50) so a notification is visible over a dialog. */
-    readonly toast: "z-[55]";
-};

package/dist/os/layers.js

@@ -1,23 +0,0 @@
-/**
- * The layer contract for the OS shell.
- *
- * The hard rule desktop UIs get wrong: a pane's z-index must NEVER be able to
- * cover a menu, toast, or the taskbar's command dropdown. We guarantee that structurally rather
- * than by juggling numbers — the `Desktop` surface is an isolated stacking
- * context (`isolate`), so every pane's z-index (1..N, handed out by the
- * PaneManager) is *contained* within it. OS chrome and portalled overlays
- * render OUTSIDE that context, at the document root, so they always paint above
- * the entire desktop no matter how high a pane's z climbs.
- *
- * These are the root-level tiers (all above the isolated desktop). bits-ui
- * dialogs/menus/tooltips portal to <body> at z-50; the tiers below are chosen
- * around that: chrome sits under menus, transient system UI sits over them.
- */
-export const LAYER = {
-    /** Taskbar / dock — chrome, below menus so a taskbar dropdown (z-50) opens over it. */
-    taskbar: 'z-30',
-    /** Slide-over notification center — chrome, same band as the taskbar it hangs off. */
-    notificationCenter: 'z-40',
-    /** Toasts — above bits-ui overlays (z-50) so a notification is visible over a dialog. */
-    toast: 'z-[55]'
-};