@quillmark/svelte 0.0.0

package/dist/core/codec/schema.js

@@ -0,0 +1,155 @@
+// The PM schema: the codec OWNS it; decode/encode target it. Nodes mirror the
+// content block kinds (para/heading/code/rule/island) and its container nesting
+// (list_item/quote → lists/blockquote); marks mirror the content formatting set.
+// Each of the three open sets gets an inert carrier so an unrecognized value
+// survives a round-trip: the `unknown` mark, the paragraph's `unknown` attribute,
+// and the `unknown_container` node. `blockSchema` is the full field; `inlineSchema`
+// is the constrained single-textblock form for `richtext(inline)` / `plaintext`
+// (one paragraph, no block split, no containers, no islands): same decode/lower/
+// position machinery, narrower shape. Anchors are NOT marks here (decorations).
+import { Schema } from 'prosemirror-model';
+import { islandBlockSpec, islandInlineSpec } from './islands.js';
+// ── Marks (shared by both schemas; plaintext mounts none) ───────────────────
+const marks = {
+    // Order matters: it fixes mark-set sort order and parse precedence. `link`
+    // last so it wraps outermost; `unknown` after it, non-exclusive so several
+    // distinct unknown marks coexist on one range.
+    strong: { parseDOM: [{ tag: 'strong' }, { tag: 'b' }], toDOM: () => ['strong', 0] },
+    em: { parseDOM: [{ tag: 'em' }, { tag: 'i' }], toDOM: () => ['em', 0] },
+    underline: { parseDOM: [{ tag: 'u' }], toDOM: () => ['u', 0] },
+    strike: { parseDOM: [{ tag: 's' }, { tag: 'del' }], toDOM: () => ['s', 0] },
+    code: { parseDOM: [{ tag: 'code' }], toDOM: () => ['code', 0] },
+    link: {
+        attrs: { href: { default: '' } },
+        inclusive: false,
+        parseDOM: [
+            { tag: 'a[href]', getAttrs: (el) => ({ href: el.getAttribute('href') }) }
+        ],
+        toDOM: (mark) => ['a', { href: mark.attrs.href }, 0]
+    },
+    // The open-set escape hatch: an inert mark that renders as a bare span and
+    // re-emits its stored `type`/`attrs` on encode. `excludes: ''` lets marks of
+    // this type with different attrs share a range (they are distinct families).
+    unknown: {
+        attrs: { type: { default: '' }, attrs: { default: null } },
+        excludes: '',
+        toDOM: () => ['span', { 'data-unknown': '' }, 0]
+    }
+};
+// ── Block nodes ─────────────────────────────────────────────────────────────
+const blockNodes = {
+    doc: { content: 'block+' },
+    // `unknown` carries a line `kind` this build does not know (`{ kind, attrs }`,
+    // else null). A paragraph IS how such a line renders, so the carrier is an
+    // attribute rather than a node type: every paragraph command already reaches it,
+    // and retyping it to a heading or a list drops the attribute: an explicit
+    // conversion, which is the one place the unknown kind SHOULD be lost.
+    paragraph: {
+        content: 'inline*',
+        group: 'block',
+        attrs: { unknown: { default: null } },
+        parseDOM: [{ tag: 'p' }],
+        toDOM: (node) => {
+            const u = node.attrs.unknown;
+            return u ? ['p', { 'data-qm-unknown-line': u.kind }, 0] : ['p', 0];
+        }
+    },
+    heading: {
+        content: 'inline*',
+        group: 'block',
+        defining: true,
+        attrs: { level: { default: 1 } },
+        parseDOM: [1, 2, 3, 4, 5, 6].map((level) => ({ tag: `h${level}`, attrs: { level } })),
+        toDOM: (node) => [`h${node.attrs.level}`, 0]
+    },
+    code_block: {
+        content: 'text*',
+        group: 'block',
+        code: true,
+        defining: true,
+        marks: '',
+        whitespace: 'pre',
+        attrs: { lang: { default: null } },
+        parseDOM: [{ tag: 'pre', preserveWhitespace: 'full' }],
+        toDOM: (node) => [
+            'pre',
+            node.attrs.lang ? { 'data-lang': node.attrs.lang } : {},
+            ['code', 0]
+        ]
+    },
+    blockquote: {
+        content: 'block+',
+        group: 'block',
+        defining: true,
+        parseDOM: [{ tag: 'blockquote' }],
+        toDOM: () => ['blockquote', 0]
+    },
+    horizontal_rule: { group: 'block', parseDOM: [{ tag: 'hr' }], toDOM: () => ['hr'] },
+    ordered_list: {
+        content: 'list_item+',
+        group: 'block',
+        attrs: { start: { default: 1 } },
+        parseDOM: [{ tag: 'ol' }],
+        toDOM: (node) => node.attrs.start === 1 ? ['ol', 0] : ['ol', { start: node.attrs.start }, 0]
+    },
+    bullet_list: {
+        content: 'list_item+',
+        group: 'block',
+        parseDOM: [{ tag: 'ul' }],
+        toDOM: () => ['ul', 0]
+    },
+    list_item: {
+        content: 'block+',
+        defining: true,
+        parseDOM: [{ tag: 'li' }],
+        toDOM: () => ['li', 0]
+    },
+    // A container this build does not know: a transparent wrapper that renders as a
+    // bare block (its children flow at the enclosing level, which is how upstream
+    // renders it) and re-emits its `container`/`attrs` on encode. `defining` so a
+    // lift out of it is deliberate rather than a backspace away.
+    unknown_container: {
+        content: 'block+',
+        group: 'block',
+        defining: true,
+        attrs: { container: { default: '' }, attrs: { default: null } },
+        toDOM: (node) => ['div', { 'data-qm-unknown-container': node.attrs.container }, 0]
+    },
+    island_block: islandBlockSpec
+};
+// ── Inline nodes ────────────────────────────────────────────────────────────
+const inlineLeafNodes = {
+    text: { group: 'inline' },
+    hard_break: {
+        inline: true,
+        group: 'inline',
+        selectable: false,
+        parseDOM: [{ tag: 'br' }],
+        toDOM: () => ['br']
+    },
+    island_inline: islandInlineSpec
+};
+/** The full field schema: every block kind, container, mark, and island. */
+export const blockSchema = new Schema({
+    nodes: { ...blockNodes, ...inlineLeafNodes },
+    marks
+});
+/**
+ * The constrained inline schema: one paragraph, no block splitting, no
+ * containers, no islands. `doc: "paragraph"` (exactly one child) is what makes an
+ * Enter a no-op at the model level: there is no second block for a split to land.
+ * Marks are present; `plaintext` fields strip them at decode and mount no
+ * mark input (a schema-level distinction the field draws, per CODEC §Inline mode).
+ */
+export const inlineSchema = new Schema({
+    nodes: {
+        doc: { content: 'paragraph' },
+        paragraph: { content: 'inline*', toDOM: () => ['p', 0] },
+        text: { group: 'inline' }
+    },
+    marks
+});
+/** True for the constrained inline schema (no block containers); decode branches on it. */
+export function isInlineSchema(schema) {
+    return !schema.nodes.blockquote;
+}

package/dist/core/codec/slash.d.ts

@@ -0,0 +1,79 @@
+import { Plugin, type Command } from 'prosemirror-state';
+import type { EditorView } from 'prosemirror-view';
+import { type RangeAnchor } from './anchor.js';
+/** One offer in the menu: what the chrome draws, and what a pick names. */
+export interface SlashItem {
+    id: string;
+    label: string;
+}
+/** The menu as the chrome sees it: the filtered offers, the keyboard's cursor, and
+ *  the trigger's anchor to hang off. `undefined` is a closed menu. */
+export interface SlashState {
+    items: SlashItem[];
+    index: number;
+    query: string;
+    /** The trigger's caret to hang off, live rather than measured (`anchor.ts`): an
+     *  open menu outlives any one scroll position of the leaf. */
+    anchor: RangeAnchor;
+}
+/** The menu's wording. Each label is also its own search key (§`filterItems`), so a
+ *  translated menu filters in the language it is displayed in. */
+export interface SlashStrings {
+    slashLabel: string;
+    slashTable: string;
+    slashBulletList: string;
+    slashOrderedList: string;
+}
+/** The package's English, beside the surface that draws it: the same rule the island
+ *  chrome's wording follows, and the visual `strings` set extends both. */
+export declare const DEFAULT_SLASH_STRINGS: SlashStrings;
+/** The menu's offers, in order, from a wording. The set is the CONTAINERS: a construct
+ *  that opens a place the caret then lives in. A construct that retypes the block the
+ *  caret is already in (a heading, a quote, a code block, a divider) is the
+ *  shorthand's, not the menu's. The island is first, being the one with no
+ *  shorthand at all. */
+export declare function slashItems(s: SlashStrings): SlashItem[];
+/** The query filter: a substring of the LABEL, or a prefix of the id. The label is
+ *  what the user reads, so it is the primary key; the id catches the shorthands a
+ *  label does not carry (`/h1`, `/ul` never having been words). Both
+ *  case-insensitive; an empty query offers everything. */
+export declare function filterItems(items: SlashItem[], query: string): SlashItem[];
+/** The live trigger: where the `/` sits, what has been typed after it, and which
+ *  offer the keyboard is on. */
+interface SlashRun {
+    from: number;
+    query: string;
+    index: number;
+}
+/**
+ * The trigger plugin. It holds the run in PM state, so every ordinary dismissal is
+ * free: a caret move out of it, an undo, or a re-hydrate all fail the recompute
+ * below and close the menu without a listener of their own. A dismissal edits no
+ * text; only a pick does, and it consumes exactly the run.
+ */
+export declare function slashPlugin(opts: {
+    items: () => SlashItem[];
+    onState: (state: SlashState | undefined) => void;
+}): Plugin<SlashRun | null>;
+/**
+ * The menu's keys, the INNERMOST link of the leaf's chain (`keymap.ts`). Every one
+ * declines when no run is live, so a body with no menu open keeps Enter, Escape and
+ * the arrows exactly as it had them.
+ *
+ * Escape is the contended key: a table gives it three claimants (this menu, the
+ * format popover, an island selection). Innermost first, and this is the innermost
+ * of the three that can be open over a caret in text.
+ */
+export declare function slashKeymap(items: () => SlashItem[]): Record<string, Command>;
+/** Move the keyboard cursor onto `id`: what a pointer entering an item calls, so the
+ *  highlight has ONE lane rather than a hover painting a second one. */
+export declare function focusSlashItem(view: EditorView, id: string, items: SlashItem[]): void;
+/**
+ * Run an offer: ONE transaction that deletes the trigger run and applies the item's
+ * own edit. One rather than two because two would be two commits, two undo steps and
+ * two recompiles for one gesture; the item's command is built against the post-delete
+ * state and its steps are replayed onto the same transaction, which is exactly what
+ * they were computed for.
+ */
+export declare function runSlashItem(view: EditorView, id: string): void;
+export {};

package/dist/core/codec/table-view.d.ts

@@ -0,0 +1,50 @@
+import { EditorView, type NodeViewConstructor } from 'prosemirror-view';
+/** Everything the island's chrome says. Accessible names, not decoration: a handle
+ *  is a bar and a seam is a glyph, so an untranslated one reads the wrong language
+ *  rather than merely inconsistent (VISUAL_EDITOR §"What the surface says"). */
+export interface TableChromeStrings {
+    /** The island's own name, on the wrapper. */
+    tableLabel: string;
+    /** Row 0 is the header, which is not "Row 0". */
+    tableHeaderRow: string;
+    tableRow: (index: number) => string;
+    tableColumn: (index: number) => string;
+    /** A cell's accessible name: nothing else names a nested leaf. */
+    tableCell: (row: string, column: string) => string;
+    /** A handle's name. It SELECTS its line, and the verbs are then the selection's
+     *  (Backspace, Alt+arrows), so the name is the gesture and not a menu's. */
+    tableSelectRow: (index: number) => string;
+    tableSelectColumn: (index: number) => string;
+    /** The corner's, whose line is the whole table. */
+    tableSelectTable: string;
+    /** A seam's, named by the line it would open rather than by a neighbour and a
+     *  side: "insert row 3" is one fact where "insert below row 2" is two. */
+    tableInsertRow: (index: number) => string;
+    tableInsertColumn: (index: number) => string;
+    tableAlignDefault: string;
+    tableAlignLeft: string;
+    tableAlignCenter: string;
+    tableAlignRight: string;
+}
+/**
+ * The package's English for the island chrome. It lives HERE, beside the surface
+ * that draws it, rather than in the visual tier's table: the codec mounts this
+ * chrome and a consumer reaching `createField` directly gets wording with it. The
+ * visual `strings` set extends this one, so a consumer overrides these keys beside
+ * every other key and there is still one English list.
+ */
+export declare const DEFAULT_TABLE_STRINGS: TableChromeStrings;
+/** What the field hands each island view: its wording (read live, so a locale swap
+ *  re-renders) and the callbacks that keep a nested view visible to the leaf. */
+export interface TableViewDeps {
+    strings: () => TableChromeStrings;
+    /** Register a mounted cell view; the returned function unregisters it. The field
+     *  needs the set to answer "which view holds the caret" for the format popover. */
+    register: (view: EditorView) => () => void;
+    /** A cell took focus: the leaf's own `focus` handler never fires for one (a focus
+     *  event does not bubble), so the active address would not follow the caret. */
+    onCellFocus: () => void;
+}
+/** The `island_block` node view: a table island's editing surface, and the literal
+ *  placeholder for every other island type. */
+export declare function tableNodeView(deps: TableViewDeps): NodeViewConstructor;