@quillmark/svelte 0.1.1 → 0.3.0

package/dist/core/codec/schema.js

@@ -1,4 +1,4 @@
-// The PM schema: the codec OWNS it; decode/encode target it. Nodes mirror the
+// 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
@@ -6,7 +6,7 @@
 // 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).
+// 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) ───────────────────
@@ -40,10 +40,10 @@ const marks = {
 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
+    // 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.
+    // conversion, which is the one place the unknown kind should be lost.
     paragraph: {
         content: 'inline*',
         group: 'block',

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

@@ -1,43 +1,43 @@
 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. */
+/** The menu as the chrome sees it: the command names the query matched, the keyboard's
+ *  cursor, and the trigger's anchor to hang off. `undefined` is a closed menu.
+ *
+ *  An empty `items` is a live trigger with nothing to offer, and nothing is drawn over
+ *  it. The run is the shape of the text (a `/` at a boundary, no whitespace since) and
+ *  the menu the shape of the match; splitting the two is what lets a query typed past
+ *  the last match narrow back into one. */
 export interface SlashState {
-    items: SlashItem[];
+    items: string[];
     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. */
+/** The menu's wording, which is its accessible name and nothing else: the offers are
+ *  command names, and a name is not translated. */
 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 vocabulary, in menu order: the names `SLASH_COMMANDS` is keyed by, read off the
+ * table itself so an offer and its pick cannot disagree.
+ *
+ * The set is what no shorthand reaches. A list is `- ` / `1. `, a heading `# `, a quote
+ * `> `, a rule `---`, a code block a fence: a shorthand fires where the caret already
+ * is, and a second door onto the same construct is a second thing to keep true. A table
+ * has no prefix a rule can fire on (a pipe row is not one), so it is the menu's alone.
+ */
+export declare function slashItems(): string[];
+/** The query filter: a case-insensitive prefix of the name, which is how a command line
+ *  completes. An empty query offers everything, and the vocabulary's order survives, so
+ *  the menu never reorders under a keystroke. */
+export declare function filterItems(items: string[], query: string): string[];
 /** The live trigger: where the `/` sits, what has been typed after it, and which
  *  offer the keyboard is on. */
 interface SlashRun {
@@ -51,29 +51,27 @@ interface SlashRun {
  * 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>;
+export declare function slashPlugin(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.
+ * The menu's keys, the innermost link of the leaf's chain (`keymap.ts`). Every one
+ * declines on an empty offer list rather than on a dead run (§`SlashState`): a key an
+ * undrawn run claimed would be a key lost to a surface nobody can see. So a body with
+ * no menu on screen 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;
+export declare function slashKeymap(): Record<string, Command>;
+/** Move the keyboard cursor onto `name`: 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, name: string): 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.
+ * Run a command: one transaction that deletes the trigger run and applies the
+ * command's own edit. One rather than two because two would be two commits, two undo
+ * steps and two recompiles for one gesture; the 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 declare function runSlashItem(view: EditorView, name: string): void;
 export {};

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

@@ -1,7 +1,7 @@
 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"). */
+/** Everything the island's chrome says. Accessible names, not decoration: every
+ *  control here is a bar, 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;
@@ -11,23 +11,19 @@ export interface TableChromeStrings {
     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. */
+    /** A grip's name. It selects its line, and the verbs are then the selection's
+     *  (Backspace, Alt+arrows) or the drag's, so the name is the gesture. Row 0 takes a
+     *  name of its own for the reason it takes one above: the gesture is every other
+     *  row's, but the line it names is still the header and not "row 0". */
+    tableSelectHeaderRow: string;
     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 two trailing bars, each of which grows the table along its own axis. */
+    tableAddRow: string;
+    tableAddColumn: string;
 }
 /**
- * The package's English for the island chrome. It lives HERE, beside the surface
+ * 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