@signal9/era-ui 12.1.2 → 13.0.0

package/dist/apps/notes/note-editor.svelte

@@ -1,176 +0,0 @@
-<script lang="ts">
-	/**
-	 * The TipTap document surface.
-	 *
-	 * The editor instance is created inside an attachment so its lifetime is tied
-	 * to the element, and torn down with it. `content` is a SEED, not a bound
-	 * value: ProseMirror owns the document once it is running, so re-feeding it
-	 * every keystroke would fight the editor. The host re-seeds by re-keying this
-	 * component (`{#key noteId}`) when it switches notes.
-	 *
-	 * Prose styling lives in the scoped stylesheet below and is written entirely
-	 * against era tokens, so a document follows the density, surface, corners,
-	 * and theme axes the same way a control does.
-	 *
-	 * (Do not spell a literal style tag in this comment — svelte2tsx 0.7.58 scans
-	 * for it lexically and decides the script never closed.)
-	 */
-	import { untrack } from 'svelte';
-	import { Editor, type JSONContent } from '@tiptap/core';
-	import { noteExtensions } from './editor/extensions.js';
-	// Side-effect import: mounting the editor should not require the consumer to
-	// remember a stylesheet. Also published as `@signal9/era-ui/styles/prose`.
-	import '../../styles/prose.css';
-
-	interface Props {
-		/** Initial document. Later changes are ignored — re-key to reseed. */
-		content: JSONContent;
-		onUpdate?: (json: JSONContent) => void;
-		/** Placeholder shown on an empty first paragraph. */
-		class?: string;
-	}
-
-	let { content, onUpdate, class: className }: Props = $props();
-
-	let editor: Editor | undefined;
-
-	type MarkdownStorage = { markdown?: { getMarkdown?: () => string } };
-
-	let activeFormats = $state<Record<string, boolean>>({});
-
-	function updateActiveFormats(ed: Editor) {
-		activeFormats = {
-			bold: ed.isActive('bold'),
-			italic: ed.isActive('italic'),
-			strike: ed.isActive('strike'),
-			code: ed.isActive('code'),
-			highlight: ed.isActive('highlight'),
-			heading: ed.isActive('heading'),
-			bulletList: ed.isActive('bulletList'),
-			orderedList: ed.isActive('orderedList'),
-			taskList: ed.isActive('taskList'),
-			blockquote: ed.isActive('blockquote'),
-			codeBlock: ed.isActive('codeBlock'),
-			details: ed.isActive('details'),
-			table: ed.isActive('table'),
-			link: ed.isActive('link')
-		};
-	}
-
-	function initEditor(element: HTMLDivElement) {
-		// untrack: the attachment must not re-run when `content` or `onUpdate`
-		// change — tearing down and rebuilding the editor mid-typing would lose
-		// the selection and the undo history.
-		return untrack(() => {
-			editor = new Editor({
-				element,
-				extensions: noteExtensions,
-				content,
-				onUpdate: ({ editor: ed }) => {
-					onUpdate?.(ed.getJSON());
-					updateActiveFormats(ed);
-				},
-				onSelectionUpdate: ({ editor: ed }) => {
-					updateActiveFormats(ed);
-				}
-			});
-			return () => {
-				editor?.destroy();
-				editor = undefined;
-			};
-		});
-	}
-
-	/*
-	 * Imperative API. The bubble toolbar and slash menu already cover these for a
-	 * pointer/keyboard user; these exports exist so a HOST can drive the document
-	 * from its own chrome — a window toolbar, a command palette, an agent tool —
-	 * without reaching into TipTap itself. Bind the component and call them.
-	 */
-
-	export function isActive(name: string) {
-		return activeFormats[name] ?? false;
-	}
-
-	export function focus() {
-		editor?.chain().focus().run();
-	}
-
-	export function formatBold() {
-		editor?.chain().focus().toggleBold().run();
-	}
-	export function formatItalic() {
-		editor?.chain().focus().toggleItalic().run();
-	}
-	export function formatStrike() {
-		editor?.chain().focus().toggleStrike().run();
-	}
-	export function formatCode() {
-		editor?.chain().focus().toggleCode().run();
-	}
-	export function formatHighlight() {
-		editor?.chain().focus().toggleHighlight().run();
-	}
-	export function formatLink() {
-		if (editor) void import('./editor/link.js').then((m) => m.toggleLink(editor!));
-	}
-
-	export function formatHeading(level: 1 | 2 | 3 = 2) {
-		editor?.chain().focus().toggleHeading({ level }).run();
-	}
-	export function formatBlockquote() {
-		editor?.chain().focus().toggleBlockquote().run();
-	}
-	export function formatList() {
-		editor?.chain().focus().toggleBulletList().run();
-	}
-	export function formatOrderedList() {
-		editor?.chain().focus().toggleOrderedList().run();
-	}
-	export function formatTaskList() {
-		editor?.chain().focus().toggleTaskList().run();
-	}
-	export function formatCodeBlock() {
-		editor?.chain().focus().toggleCodeBlock().run();
-	}
-	export function formatDetails() {
-		editor?.chain().focus().setDetails().run();
-	}
-
-	export function insertTable() {
-		editor?.chain().focus().insertTable({ rows: 3, cols: 3, withHeaderRow: true }).run();
-	}
-	export function deleteTable() {
-		editor?.chain().focus().deleteTable().run();
-	}
-	export function addTableRow() {
-		editor?.chain().focus().addRowAfter().run();
-	}
-	export function addTableCol() {
-		editor?.chain().focus().addColumnAfter().run();
-	}
-	export function deleteTableRow() {
-		editor?.chain().focus().deleteRow().run();
-	}
-	export function deleteTableCol() {
-		editor?.chain().focus().deleteColumn().run();
-	}
-
-	export function insertImage() {
-		const url = globalThis.prompt?.('Image URL:');
-		if (url) editor?.chain().focus().setImage({ src: url }).run();
-	}
-
-	/** The document as markdown, via tiptap-markdown's serializer. */
-	export function getMarkdown(): string {
-		return (editor?.storage as MarkdownStorage | undefined)?.markdown?.getMarkdown?.() ?? '';
-	}
-</script>
-
-<!-- eslint-disable better-tailwindcss/no-unknown-classes -- era-notes-prose is defined in this component's scoped stylesheet -->
-<div class="era-notes-prose min-w-0 {className ?? ''}" {@attach initEditor}></div>
-
-<!-- The document styling lives in ../../styles/prose.css, imported above:
-     Svelte would scope a <style> block to this component, which is what made
-     era's prose typography unreachable for anyone building their own TipTap
-     instance. Same rules, addressable by anyone who sets .era-notes-prose. -->

package/dist/apps/notes/note-editor.svelte.d.ts

@@ -1,36 +0,0 @@
-import { type JSONContent } from '@tiptap/core';
-import '../../styles/prose.css';
-interface Props {
-    /** Initial document. Later changes are ignored — re-key to reseed. */
-    content: JSONContent;
-    onUpdate?: (json: JSONContent) => void;
-    /** Placeholder shown on an empty first paragraph. */
-    class?: string;
-}
-declare const NoteEditor: import("svelte").Component<Props, {
-    isActive: (name: string) => boolean;
-    focus: () => void;
-    formatBold: () => void;
-    formatItalic: () => void;
-    formatStrike: () => void;
-    formatCode: () => void;
-    formatHighlight: () => void;
-    formatLink: () => void;
-    formatHeading: (level?: 1 | 2 | 3) => void;
-    formatBlockquote: () => void;
-    formatList: () => void;
-    formatOrderedList: () => void;
-    formatTaskList: () => void;
-    formatCodeBlock: () => void;
-    formatDetails: () => void;
-    insertTable: () => void;
-    deleteTable: () => void;
-    addTableRow: () => void;
-    addTableCol: () => void;
-    deleteTableRow: () => void;
-    deleteTableCol: () => void;
-    insertImage: () => void;
-    getMarkdown: () => string;
-}, "">;
-type NoteEditor = ReturnType<typeof NoteEditor>;
-export default NoteEditor;

package/dist/apps/notes/notes-store.svelte.d.ts

@@ -1,64 +0,0 @@
-/**
- * The Notes data layer — reactive state plus a pluggable persistence adapter.
- *
- * The store owns the notes; the adapter owns where they live. That split is
- * deliberate: era ships a browser-only app (localStorage), but the same
- * component is meant to drop into a host that persists server-side. Such a host
- * supplies its own adapter and changes nothing else — which is why `load`/`save`
- * are allowed to return promises even though the bundled adapters are sync.
- *
- * Writes are debounced and coalesced: every mutation marks the store dirty and
- * re-arms one timer, so a burst of keystrokes costs a single `save`.
- */
-import { type Note, type NoteInit, type NotePatch } from './types.js';
-export type SaveStatus = 'idle' | 'saving' | 'saved' | 'error';
-export interface NotesAdapter {
-    load(): Note[] | Promise<Note[]>;
-    save(notes: Note[]): void | Promise<void>;
-}
-export declare const DEFAULT_STORAGE_KEY = "era-ui:notes";
-/**
- * Persist to `localStorage`. Safe to construct during SSR — it only touches
- * storage inside `load`/`save`, and returns empty / no-ops when there is none.
- */
-export declare function localStorageAdapter(key?: string): NotesAdapter;
-/** In-memory only — for demos, tests, and SSR snapshots. */
-export declare function memoryAdapter(seed?: Note[]): NotesAdapter;
-export interface NotesStoreOptions {
-    /** Where notes live. Defaults to `localStorage` under `era-ui:notes`. */
-    adapter?: NotesAdapter;
-    /** Quiet period before a burst of edits is flushed, in ms. Default 400. */
-    debounce?: number;
-    /** How long the `saved` badge lingers before falling back to `idle`, in ms. */
-    statusLinger?: number;
-}
-export declare class NotesStore {
-    #private;
-    notes: Note[];
-    /** True until the first `load()` settles — the list renders a skeleton on it. */
-    loading: boolean;
-    status: SaveStatus;
-    lastError: string | null;
-    /** Pinned first, then most-recently-touched. The order the sidebar renders. */
-    readonly ordered: Note[];
-    constructor(options?: NotesStoreOptions);
-    load(): Promise<void>;
-    get(id: string | null | undefined): Note | undefined;
-    /**
-     * Case-insensitive match over title AND body. Matching the body is why
-     * `plainText` is denormalised — the alternative is walking every document's
-     * AST on every keystroke.
-     */
-    search(query: string): Note[];
-    create(init?: NoteInit): Note;
-    update(id: string, patch: NotePatch): void;
-    remove(id: string): void;
-    togglePin(id: string): void;
-    setIcon(id: string, icon: string | null): void;
-    /** The note as markdown — for copy-out, export, or handing to a model. */
-    toMarkdown(id: string): string;
-    /** Persist immediately, cancelling any pending debounce. Safe to call spuriously. */
-    flush(): Promise<void>;
-    /** Clear timers and write out whatever is pending. Call from `onDestroy`. */
-    destroy(): void;
-}

package/dist/apps/notes/notes-store.svelte.js

@@ -1,234 +0,0 @@
-/**
- * The Notes data layer — reactive state plus a pluggable persistence adapter.
- *
- * The store owns the notes; the adapter owns where they live. That split is
- * deliberate: era ships a browser-only app (localStorage), but the same
- * component is meant to drop into a host that persists server-side. Such a host
- * supplies its own adapter and changes nothing else — which is why `load`/`save`
- * are allowed to return promises even though the bundled adapters are sync.
- *
- * Writes are debounced and coalesced: every mutation marks the store dirty and
- * re-arms one timer, so a burst of keystrokes costs a single `save`.
- */
-import { tiptapToMarkdown, textContent } from './markdown.js';
-import { EMPTY_DOC } from './types.js';
-export const DEFAULT_STORAGE_KEY = 'era-ui:notes';
-/** Loose structural check — storage is untrusted (stale schema, another tab, a
- *  user editing devtools), so a malformed entry is dropped rather than crashing
- *  the list on first render. */
-function isNote(value) {
-    if (typeof value !== 'object' || value === null)
-        return false;
-    const n = value;
-    return (typeof n.id === 'string' &&
-        typeof n.title === 'string' &&
-        typeof n.content === 'object' &&
-        n.content !== null &&
-        Array.isArray(n.content.content));
-}
-/**
- * Persist to `localStorage`. Safe to construct during SSR — it only touches
- * storage inside `load`/`save`, and returns empty / no-ops when there is none.
- */
-export function localStorageAdapter(key = DEFAULT_STORAGE_KEY) {
-    const available = () => typeof localStorage !== 'undefined';
-    return {
-        load() {
-            if (!available())
-                return [];
-            try {
-                const raw = localStorage.getItem(key);
-                if (!raw)
-                    return [];
-                const parsed = JSON.parse(raw);
-                return Array.isArray(parsed) ? parsed.filter(isNote) : [];
-            }
-            catch {
-                return [];
-            }
-        },
-        save(notes) {
-            if (!available())
-                return;
-            // Let a quota/private-mode failure reach the store so the UI can say so,
-            // rather than silently dropping the user's writing.
-            localStorage.setItem(key, JSON.stringify(notes));
-        }
-    };
-}
-/** In-memory only — for demos, tests, and SSR snapshots. */
-export function memoryAdapter(seed = []) {
-    let notes = seed;
-    return {
-        load: () => notes,
-        save: (next) => {
-            notes = next;
-        }
-    };
-}
-function newId() {
-    if (typeof crypto !== 'undefined' && 'randomUUID' in crypto)
-        return crypto.randomUUID();
-    return `note-${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
-}
-export class NotesStore {
-    #adapter;
-    #debounce;
-    #statusLinger;
-    #saveTimer = null;
-    #statusTimer = null;
-    notes = $state([]);
-    /** True until the first `load()` settles — the list renders a skeleton on it. */
-    loading = $state(true);
-    status = $state('idle');
-    lastError = $state(null);
-    /** Pinned first, then most-recently-touched. The order the sidebar renders. */
-    ordered = $derived([...this.notes].sort((a, b) => Number(b.pinned) - Number(a.pinned) || b.updatedAt - a.updatedAt));
-    constructor(options = {}) {
-        this.#adapter = options.adapter ?? localStorageAdapter();
-        this.#debounce = options.debounce ?? 400;
-        this.#statusLinger = options.statusLinger ?? 1600;
-    }
-    async load() {
-        this.loading = true;
-        try {
-            const loaded = await this.#adapter.load();
-            this.notes = loaded;
-            this.lastError = null;
-        }
-        catch (error) {
-            this.notes = [];
-            this.#fail(error);
-        }
-        finally {
-            this.loading = false;
-        }
-    }
-    get(id) {
-        if (!id)
-            return undefined;
-        return this.notes.find((n) => n.id === id);
-    }
-    /**
-     * Case-insensitive match over title AND body. Matching the body is why
-     * `plainText` is denormalised — the alternative is walking every document's
-     * AST on every keystroke.
-     */
-    search(query) {
-        const q = query.trim().toLowerCase();
-        if (!q)
-            return this.ordered;
-        return this.ordered.filter((n) => n.title.toLowerCase().includes(q) || n.plainText.toLowerCase().includes(q));
-    }
-    create(init = {}) {
-        const now = Date.now();
-        const content = init.content ?? structuredClone(EMPTY_DOC);
-        const note = {
-            id: newId(),
-            title: init.title ?? 'Untitled',
-            icon: init.icon ?? null,
-            content,
-            plainText: content.content.map(textContent).join(' ').trim(),
-            pinned: init.pinned ?? false,
-            createdAt: now,
-            updatedAt: now
-        };
-        this.notes.push(note);
-        this.#schedule();
-        return note;
-    }
-    update(id, patch) {
-        const note = this.get(id);
-        if (!note)
-            return;
-        if (patch.title !== undefined)
-            note.title = patch.title;
-        if (patch.icon !== undefined)
-            note.icon = patch.icon;
-        if (patch.pinned !== undefined)
-            note.pinned = patch.pinned;
-        if (patch.content !== undefined) {
-            note.content = patch.content;
-            note.plainText = patch.content.content.map(textContent).join(' ').trim();
-        }
-        note.updatedAt = Date.now();
-        this.#schedule();
-    }
-    remove(id) {
-        const index = this.notes.findIndex((n) => n.id === id);
-        if (index < 0)
-            return;
-        this.notes.splice(index, 1);
-        this.#schedule();
-    }
-    togglePin(id) {
-        const note = this.get(id);
-        if (!note)
-            return;
-        // Pinning is an ordering change, not an edit — leave `updatedAt` alone so a
-        // pin doesn't shuffle the note to the top of the recency list as well.
-        note.pinned = !note.pinned;
-        this.#schedule();
-    }
-    setIcon(id, icon) {
-        this.update(id, { icon });
-    }
-    /** The note as markdown — for copy-out, export, or handing to a model. */
-    toMarkdown(id) {
-        const note = this.get(id);
-        if (!note)
-            return '';
-        const heading = note.title ? `# ${note.title}\n\n` : '';
-        return heading + tiptapToMarkdown(note.content);
-    }
-    /** Persist immediately, cancelling any pending debounce. Safe to call spuriously. */
-    async flush() {
-        if (this.#saveTimer) {
-            clearTimeout(this.#saveTimer);
-            this.#saveTimer = null;
-        }
-        await this.#persist();
-    }
-    /** Clear timers and write out whatever is pending. Call from `onDestroy`. */
-    destroy() {
-        if (this.#statusTimer)
-            clearTimeout(this.#statusTimer);
-        this.#statusTimer = null;
-        void this.flush();
-    }
-    #schedule() {
-        this.status = 'saving';
-        if (this.#saveTimer)
-            clearTimeout(this.#saveTimer);
-        this.#saveTimer = setTimeout(() => {
-            this.#saveTimer = null;
-            void this.#persist();
-        }, this.#debounce);
-    }
-    async #persist() {
-        try {
-            await this.#adapter.save($state.snapshot(this.notes));
-            this.lastError = null;
-            this.#flash('saved');
-        }
-        catch (error) {
-            this.#fail(error);
-        }
-    }
-    #flash(status) {
-        this.status = status;
-        if (this.#statusTimer)
-            clearTimeout(this.#statusTimer);
-        this.#statusTimer = setTimeout(() => {
-            this.#statusTimer = null;
-            this.status = 'idle';
-        }, this.#statusLinger);
-    }
-    #fail(error) {
-        this.lastError = error instanceof Error ? error.message : String(error);
-        this.status = 'error';
-        if (this.#statusTimer)
-            clearTimeout(this.#statusTimer);
-        this.#statusTimer = null;
-    }
-}