@inshapardaz/likhari-react 0.1.18-dev.148 → 0.1.18-dev.152

package/dist/blocks/PoetryNode.d.ts

@@ -7,14 +7,17 @@ export type SerializedPoetryBlockNode = Spread<{
     width?: number;
 }, SerializedElementNode>;
 /**
- * A couplet (two-line verse unit), the one extensible primitive requirements
- * doc §4.11 recommends in place of four fixed templates. `layout` picks
- * single-column (two stacked misras) vs. two-column (built on the columns
- * primitive, §4.9 — see blocks/poetryActions.ts for how children are
- * restructured between the two); `align` is a literal per-instance override,
- * independent of the document's own alignment setting (architecture doc
- * §3.1). Both mutate in place via poetryActions so converting a couplet
- * between layouts doesn't lose selection/undo coherence.
+ * A poetry *section*: one or more couplets (two-line verse units) sharing
+ * one layout — single-column stacks each couplet's two misras directly as
+ * paragraph children (two per couplet, in order), two-column gives each
+ * couplet its own LayoutContainerNode row (built on the columns primitive,
+ * §4.9) — see blocks/poetryActions.ts's $getCouplets for how either shape
+ * is read, and $setPoetryLayout/$exitPoetryOnEnter for how children are
+ * restructured/grown between couplets and layouts. `layout` and `align`
+ * apply to the whole section, not per couplet; both mutate in place via
+ * poetryActions so converting a section between layouts doesn't lose
+ * selection/undo coherence. One extensible primitive in place of four
+ * fixed templates, per requirements doc §4.11.
  */
 export declare class PoetryBlockNode extends ElementNode {
     __layout: PoetryLayout;

package/dist/blocks/PoetryNode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PoetryNode.d.ts","sourceRoot":"","sources":["../../src/blocks/PoetryNode.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC1B,KAAK,MAAM,EACX,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,YAAY,CAAC;AACnD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAwBjE,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,qBAAqB,CAAC,CAAC;AAEpI;;;;;;;;;GASG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB;8DAC0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC;gBAEL,MAAM,GAAE,YAAuB,EAAE,KAAK,GAAE,WAAuB,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAO1G,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe;IAIpD,SAAS,IAAI,YAAY;IAIzB,QAAQ,IAAI,WAAW;IAIvB,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAMzC;;gEAE4D;IAC5D,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAM9C,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAMlC,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,yBAAyB,GAAG,eAAe;IAI7E,UAAU,IAAI,yBAAyB;IAYvC,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAe3C,SAAS,IAAI,eAAe;IAW5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAa5C,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO;IAerF,UAAU,IAAI,KAAK;IAInB,YAAY,IAAI,OAAO;CAGxB;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,YAAuB,EAAE,KAAK,GAAE,WAAuB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CAEvI;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,eAAe,CAEhG"}
+{"version":3,"file":"PoetryNode.d.ts","sourceRoot":"","sources":["../../src/blocks/PoetryNode.tsx"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,OAAO,EACZ,KAAK,qBAAqB,EAC1B,KAAK,MAAM,EACX,WAAW,EACZ,MAAM,SAAS,CAAC;AAEjB,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,YAAY,CAAC;AACnD,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAwBjE,MAAM,MAAM,yBAAyB,GAAG,MAAM,CAAC;IAAE,MAAM,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,EAAE,qBAAqB,CAAC,CAAC;AAEpI;;;;;;;;;;;;GAYG;AACH,qBAAa,eAAgB,SAAQ,WAAW;IAC9C,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,WAAW,CAAC;IACrB;8DAC0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC;gBAEL,MAAM,GAAE,YAAuB,EAAE,KAAK,GAAE,WAAuB,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,OAAO;IAO1G,MAAM,CAAC,OAAO,IAAI,MAAM;IAIxB,MAAM,CAAC,KAAK,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe;IAIpD,SAAS,IAAI,YAAY;IAIzB,QAAQ,IAAI,WAAW;IAIvB,QAAQ,IAAI,MAAM,GAAG,SAAS;IAI9B,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;IAMzC;;gEAE4D;IAC5D,kBAAkB,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAM9C,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAMlC,MAAM,CAAC,UAAU,CAAC,cAAc,EAAE,yBAAyB,GAAG,eAAe;IAI7E,UAAU,IAAI,yBAAyB;IAYvC,MAAM,CAAC,SAAS,IAAI,gBAAgB,GAAG,IAAI;IAe3C,SAAS,IAAI,eAAe;IAW5B,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,WAAW;IAa5C,SAAS,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO;IAerF,UAAU,IAAI,KAAK;IAInB,YAAY,IAAI,OAAO;CAGxB;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,YAAuB,EAAE,KAAK,GAAE,WAAuB,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CAEvI;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,IAAI,eAAe,CAEhG"}

package/dist/blocks/PoetryNode.js

@@ -22,14 +22,17 @@ function applyWidthStyle(element, width) {
         element.style.maxWidth = `${width}px`;
 }
 /**
- * A couplet (two-line verse unit), the one extensible primitive requirements
- * doc §4.11 recommends in place of four fixed templates. `layout` picks
- * single-column (two stacked misras) vs. two-column (built on the columns
- * primitive, §4.9 — see blocks/poetryActions.ts for how children are
- * restructured between the two); `align` is a literal per-instance override,
- * independent of the document's own alignment setting (architecture doc
- * §3.1). Both mutate in place via poetryActions so converting a couplet
- * between layouts doesn't lose selection/undo coherence.
+ * A poetry *section*: one or more couplets (two-line verse units) sharing
+ * one layout — single-column stacks each couplet's two misras directly as
+ * paragraph children (two per couplet, in order), two-column gives each
+ * couplet its own LayoutContainerNode row (built on the columns primitive,
+ * §4.9) — see blocks/poetryActions.ts's $getCouplets for how either shape
+ * is read, and $setPoetryLayout/$exitPoetryOnEnter for how children are
+ * restructured/grown between couplets and layouts. `layout` and `align`
+ * apply to the whole section, not per couplet; both mutate in place via
+ * poetryActions so converting a section between layouts doesn't lose
+ * selection/undo coherence. One extensible primitive in place of four
+ * fixed templates, per requirements doc §4.11.
  */
 export class PoetryBlockNode extends ElementNode {
     constructor(layout = 'single', align = 'justify', width, key) {

package/dist/blocks/poetryActions.d.ts

@@ -1,51 +1,82 @@
 import { type ParagraphNode } from 'lexical';
 import { type PoetryAlign, type PoetryLayout, type PoetryBlockNode } from './PoetryNode.js';
-/** The couplet's two misra paragraphs, in document order, regardless of
- * which layout currently holds them. */
+/** One couplet's two misra paragraphs, in order. */
+export type Couplet = [ParagraphNode, ParagraphNode];
+/**
+ * A poetry block is a *section* of one or more couplets sharing one layout
+ * (single-column stacks each couplet's two misras directly as paragraph
+ * children, two deep per couplet; two-column gives each couplet its own
+ * LayoutContainerNode row). This walks that structure and returns each
+ * couplet as a pair, in document order — the one place that knows how to
+ * read either shape, so nothing else needs to.
+ */
+export declare function $getCouplets(node: PoetryBlockNode): Couplet[];
+/** Every misra in the block, flattened across all its couplets — for
+ * operations (like $setPoetryLayout) that don't care about couplet
+ * boundaries, just the full set of lines. */
 export declare function $getMisraParagraphs(node: PoetryBlockNode): ParagraphNode[];
 /** The PoetryBlockNode the current selection is inside, or null. */
 export declare function $getPoetryBlockFromSelection(): PoetryBlockNode | null;
 /**
- * Converts a couplet between single-column (two stacked misras) and
- * two-column (built on the columns primitive, §4.9) in place — pulls the
- * two misra paragraphs out of whichever shape currently holds them and
- * rebuilds the other shape around the same paragraph nodes, so content,
- * selection and undo history all survive the conversion.
+ * Converts every couplet in the block between single-column (two stacked
+ * misras) and two-column (built on the columns primitive, §4.9) in place —
+ * pulls each couplet's two misra paragraphs out of whichever shape
+ * currently holds them and rebuilds the other shape around the same
+ * paragraph nodes, preserving couplet order, so content, selection and
+ * undo history all survive the conversion.
  */
 export declare function $setPoetryLayout(node: PoetryBlockNode, layout: PoetryLayout): void;
-/** A couplet at the very end of the document would otherwise leave no
+/** A block at the very end of the document would otherwise leave no
  * editable block to click or arrow down into — appends one empty paragraph
- * if the couplet doesn't already have a next sibling. Idempotent: once a
+ * if the block doesn't already have a next sibling. Idempotent: once a
  * sibling exists (that paragraph, or anything else), this is a no-op, so
  * it's safe to call from both the insert command and a node transform that
  * keeps the invariant even after later edits (e.g. deleting the trailing
  * paragraph, or JSON content loaded without one). */
 export declare function $ensureTrailingParagraph(node: PoetryBlockNode): void;
-/** Inserts a new two-misra couplet after the selection's top-level block,
- * in `layout`/`align`, and focuses its first misra. */
+/**
+ * Inserts a poetry couplet at the caret. If the caret is already inside a
+ * poetry block, appends a new couplet to *that* block (in its existing
+ * layout — "one poetry block can contain one or more couplets, in one or
+ * two column layout", so a block's layout is fixed once it has couplets,
+ * not chosen per couplet) and focuses its first misra. Otherwise creates a
+ * new block (in `layout`/`align`) with one couplet, after the selection's
+ * top-level element.
+ */
 export declare function $insertPoetryCouplet(layout: PoetryLayout, align: PoetryAlign): boolean;
-/** Removes the whole couplet the selection is inside, if any — the explicit,
- * always-available counterpart to $deletePoetryOnBackspace's empty-couplet
- * shortcut (mirrors the table menu's own "Delete table" action). */
+/** Removes the couplet the selection is inside. If it's the block's only
+ * couplet, removes the whole block (an empty poetry section serves no
+ * purpose) — the explicit, always-available counterpart to
+ * $deletePoetryOnBackspace's empty-couplet shortcut (mirrors the table
+ * menu's own "Delete table" action). */
 export declare function $deletePoetryCouplet(): boolean;
 /**
- * Backspace at the very start of an empty couplet's first misra removes the
- * whole block — the natural keystroke to try first, and otherwise there was
- * no way to get rid of an empty couplet created by mistake (its two misra
- * paragraphs each have their own default canBeEmpty, so Lexical's usual
- * "delete the empty block" handling never reaches the couplet itself).
- * Returns false for every other caret position, including a non-empty
- * couplet, so normal Backspace handling (e.g. deleting within text) proceeds.
+ * Backspace at the very start of an empty couplet removes just that
+ * couplet — merging back into the previous one's end, or (if it's the
+ * block's only couplet) removing the whole block, since an empty poetry
+ * section serves no purpose. Otherwise there was no way to get rid of an
+ * empty couplet created by mistake (its misra paragraphs each have their
+ * own default canBeEmpty, so Lexical's usual "delete the empty block"
+ * handling never reaches the couplet itself). Returns false for every
+ * other caret position, including a non-empty couplet, so normal Backspace
+ * handling (e.g. deleting within text) proceeds.
  */
 export declare function $deletePoetryOnBackspace(): boolean;
 /**
- * Enter at the end of a couplet's last misra would otherwise land inside
- * ParagraphNode's own insertNewAfter — which inserts the new paragraph as a
- * sibling of the misra, i.e. still inside the couplet (or, for two-column,
- * inside its LayoutItemNode) — trapping the caret with no way to add a line
- * after the block. Handled here instead: a plain paragraph after the whole
- * couplet, focused. Returns false (let normal Enter handling proceed) for
- * every other caret position, including earlier in the couplet.
+ * Enter inside a poetry block never grows a couplet past its fixed two
+ * misras. The block's *last* couplet being completely empty is always the
+ * exit trigger, regardless of which of its two (both-empty) misras the
+ * caret happens to be on — pressing Enter once on a non-empty last couplet
+ * appends a fresh empty one to continue into ("new couplet after last"),
+ * and pressing Enter again on that still-untouched couplet exits ("double
+ * enter to exit the block"): the same empty-item convention most editors
+ * use for lists. Outside that case: pressed in a couplet's first misra,
+ * Enter moves the caret to the second (already there; nothing inserted —
+ * this is what stops ParagraphNode's default insertNewAfter from growing
+ * the couplet, which would otherwise insert the new paragraph as a sibling
+ * of wherever the caret was, i.e. still inside the couplet); pressed in
+ * the last misra of a couplet that isn't the block's last, it moves to the
+ * next couplet's first misra.
  */
 export declare function $exitPoetryOnEnter(): boolean;
 //# sourceMappingURL=poetryActions.d.ts.map

package/dist/blocks/poetryActions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"poetryActions.d.ts","sourceRoot":"","sources":["../../src/blocks/poetryActions.ts"],"names":[],"mappings":"AACA,OAAO,EAA4F,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAEvI,OAAO,EAA8C,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAErI;wCACwC;AACxC,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,EAAE,CAW1E;AAED,oEAAoE;AACpE,wBAAgB,4BAA4B,IAAI,eAAe,GAAG,IAAI,CAKrE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAclF;AAED;;;;;;qDAMqD;AACrD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAEpE;AAED;uDACuD;AACvD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAyBtF;AAED;;oEAEoE;AACpE,wBAAgB,oBAAoB,IAAI,OAAO,CAK9C;AAED;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAoBlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAuB5C"}
+{"version":3,"file":"poetryActions.d.ts","sourceRoot":"","sources":["../../src/blocks/poetryActions.ts"],"names":[],"mappings":"AACA,OAAO,EAA4F,KAAK,aAAa,EAAE,MAAM,SAAS,CAAC;AAEvI,OAAO,EAA8C,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,eAAe,EAAE,MAAM,cAAc,CAAC;AAErI,oDAAoD;AACpD,MAAM,MAAM,OAAO,GAAG,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;AAErD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,eAAe,GAAG,OAAO,EAAE,CAgB7D;AAED;;6CAE6C;AAC7C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,aAAa,EAAE,CAE1E;AAED,oEAAoE;AACpE,wBAAgB,4BAA4B,IAAI,eAAe,GAAG,IAAI,CAKrE;AA2BD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,YAAY,GAAG,IAAI,CAmBlF;AAED;;;;;;qDAMqD;AACrD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,IAAI,CAEpE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,YAAY,EAAE,KAAK,EAAE,WAAW,GAAG,OAAO,CAmBtF;AAED;;;;wCAIwC;AACxC,wBAAgB,oBAAoB,IAAI,OAAO,CAwB9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CAqClD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAgD5C"}

package/dist/blocks/poetryActions.js

@@ -2,20 +2,38 @@ import { $findMatchingParent } from '@lexical/utils';
 import { $createParagraphNode, $getSelection, $isElementNode, $isParagraphNode, $isRangeSelection } from 'lexical';
 import { $createLayoutContainerNode, $createLayoutItemNode, $isLayoutContainerNode, $isLayoutItemNode } from './LayoutNode.js';
 import { $createPoetryBlockNode, $isPoetryBlockNode } from './PoetryNode.js';
-/** The couplet's two misra paragraphs, in document order, regardless of
- * which layout currently holds them. */
-export function $getMisraParagraphs(node) {
+/**
+ * A poetry block is a *section* of one or more couplets sharing one layout
+ * (single-column stacks each couplet's two misras directly as paragraph
+ * children, two deep per couplet; two-column gives each couplet its own
+ * LayoutContainerNode row). This walks that structure and returns each
+ * couplet as a pair, in document order — the one place that knows how to
+ * read either shape, so nothing else needs to.
+ */
+export function $getCouplets(node) {
     if (node.getLayout() === 'single') {
-        return node.getChildren().filter($isParagraphNode);
-    }
-    const container = node.getChildren().find($isLayoutContainerNode);
-    if (!container)
-        return [];
-    return container
-        .getChildren()
-        .filter($isLayoutItemNode)
-        .map((item) => item.getFirstChild())
-        .filter($isParagraphNode);
+        const paragraphs = node.getChildren().filter($isParagraphNode);
+        const couplets = [];
+        for (let i = 0; i + 1 < paragraphs.length; i += 2)
+            couplets.push([paragraphs[i], paragraphs[i + 1]]);
+        return couplets;
+    }
+    const containers = node.getChildren().filter($isLayoutContainerNode);
+    const couplets = [];
+    for (const container of containers) {
+        const items = container.getChildren().filter($isLayoutItemNode);
+        const a = items[0]?.getFirstChild();
+        const b = items[1]?.getFirstChild();
+        if ($isParagraphNode(a) && $isParagraphNode(b))
+            couplets.push([a, b]);
+    }
+    return couplets;
+}
+/** Every misra in the block, flattened across all its couplets — for
+ * operations (like $setPoetryLayout) that don't care about couplet
+ * boundaries, just the full set of lines. */
+export function $getMisraParagraphs(node) {
+    return $getCouplets(node).flat();
 }
 /** The PoetryBlockNode the current selection is inside, or null. */
 export function $getPoetryBlockFromSelection() {
@@ -25,36 +43,65 @@ export function $getPoetryBlockFromSelection() {
     const match = $findMatchingParent(selection.anchor.getNode(), $isPoetryBlockNode);
     return match ?? null;
 }
+/** Which couplet (and which of its two misras, 0 or 1) a node sits inside,
+ * or null if it's in neither — e.g. on the block's own boundary. */
+function $findCoupletPosition(couplets, target) {
+    for (let c = 0; c < couplets.length; c++) {
+        for (const misraIndex of [0, 1]) {
+            const misra = couplets[c][misraIndex];
+            if (misra.getKey() === target.getKey() || misra.isParentOf(target))
+                return { coupletIndex: c, misraIndex };
+        }
+    }
+    return null;
+}
+function $appendCoupletTo(node) {
+    const misraA = $createParagraphNode();
+    const misraB = $createParagraphNode();
+    if (node.getLayout() === 'single') {
+        node.append(misraA, misraB);
+    }
+    else {
+        const container = $createLayoutContainerNode('repeat(2, 1fr)');
+        container.append($createLayoutItemNode().append(misraA), $createLayoutItemNode().append(misraB));
+        node.append(container);
+    }
+    return [misraA, misraB];
+}
 /**
- * Converts a couplet between single-column (two stacked misras) and
- * two-column (built on the columns primitive, §4.9) in place — pulls the
- * two misra paragraphs out of whichever shape currently holds them and
- * rebuilds the other shape around the same paragraph nodes, so content,
- * selection and undo history all survive the conversion.
+ * Converts every couplet in the block between single-column (two stacked
+ * misras) and two-column (built on the columns primitive, §4.9) in place —
+ * pulls each couplet's two misra paragraphs out of whichever shape
+ * currently holds them and rebuilds the other shape around the same
+ * paragraph nodes, preserving couplet order, so content, selection and
+ * undo history all survive the conversion.
  */
 export function $setPoetryLayout(node, layout) {
     if (node.getLayout() === layout)
         return;
-    const misras = $getMisraParagraphs(node);
-    for (const misra of misras)
-        misra.remove();
+    const couplets = $getCouplets(node);
+    for (const [a, b] of couplets) {
+        a.remove();
+        b.remove();
+    }
     for (const leftover of node.getChildren())
         leftover.remove();
     if (layout === 'single') {
-        for (const misra of misras)
-            node.append(misra);
+        for (const [a, b] of couplets)
+            node.append(a, b);
     }
     else {
-        const container = $createLayoutContainerNode('repeat(2, 1fr)');
-        for (const misra of misras)
-            container.append($createLayoutItemNode().append(misra));
-        node.append(container);
+        for (const [a, b] of couplets) {
+            const container = $createLayoutContainerNode('repeat(2, 1fr)');
+            container.append($createLayoutItemNode().append(a), $createLayoutItemNode().append(b));
+            node.append(container);
+        }
     }
     node.setLayoutAttribute(layout);
 }
-/** A couplet at the very end of the document would otherwise leave no
+/** A block at the very end of the document would otherwise leave no
  * editable block to click or arrow down into — appends one empty paragraph
- * if the couplet doesn't already have a next sibling. Idempotent: once a
+ * if the block doesn't already have a next sibling. Idempotent: once a
  * sibling exists (that paragraph, or anything else), this is a no-op, so
  * it's safe to call from both the insert command and a node transform that
  * keeps the invariant even after later edits (e.g. deleting the trailing
@@ -63,107 +110,173 @@ export function $ensureTrailingParagraph(node) {
     if (node.getNextSibling() === null)
         node.insertAfter($createParagraphNode());
 }
-/** Inserts a new two-misra couplet after the selection's top-level block,
- * in `layout`/`align`, and focuses its first misra. */
+/**
+ * Inserts a poetry couplet at the caret. If the caret is already inside a
+ * poetry block, appends a new couplet to *that* block (in its existing
+ * layout — "one poetry block can contain one or more couplets, in one or
+ * two column layout", so a block's layout is fixed once it has couplets,
+ * not chosen per couplet) and focuses its first misra. Otherwise creates a
+ * new block (in `layout`/`align`) with one couplet, after the selection's
+ * top-level element.
+ */
 export function $insertPoetryCouplet(layout, align) {
     const selection = $getSelection();
     if (!$isRangeSelection(selection))
         return false;
-    // getTopLevelElement() stops at the nearest shadow root, and a
-    // PoetryBlockNode is one — so from inside an existing couplet it resolves
-    // to the misra paragraph itself, not the couplet. Without this check, a
-    // second insert lands as a sibling of that misra (nested inside the first
-    // couplet) instead of after the couplet as a whole.
-    const anchorTopLevel = $getPoetryBlockFromSelection() ?? selection.anchor.getNode().getTopLevelElementOrThrow();
-    const node = $createPoetryBlockNode(layout, align);
-    const misraA = $createParagraphNode();
-    const misraB = $createParagraphNode();
-    if (layout === 'single') {
-        node.append(misraA, misraB);
-    }
-    else {
-        const container = $createLayoutContainerNode('repeat(2, 1fr)');
-        container.append($createLayoutItemNode().append(misraA), $createLayoutItemNode().append(misraB));
-        node.append(container);
+    const existing = $getPoetryBlockFromSelection();
+    if (existing) {
+        const [misraA] = $appendCoupletTo(existing);
+        misraA.selectStart();
+        return true;
     }
+    const anchorTopLevel = selection.anchor.getNode().getTopLevelElementOrThrow();
+    const node = $createPoetryBlockNode(layout, align);
+    const [misraA] = $appendCoupletTo(node);
     anchorTopLevel.insertAfter(node);
     $ensureTrailingParagraph(node);
     misraA.selectStart();
     return true;
 }
-/** Removes the whole couplet the selection is inside, if any — the explicit,
- * always-available counterpart to $deletePoetryOnBackspace's empty-couplet
- * shortcut (mirrors the table menu's own "Delete table" action). */
+/** Removes the couplet the selection is inside. If it's the block's only
+ * couplet, removes the whole block (an empty poetry section serves no
+ * purpose) — the explicit, always-available counterpart to
+ * $deletePoetryOnBackspace's empty-couplet shortcut (mirrors the table
+ * menu's own "Delete table" action). */
 export function $deletePoetryCouplet() {
-    const couplet = $getPoetryBlockFromSelection();
-    if (!couplet)
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
         return false;
-    couplet.remove();
+    const selection = $getSelection();
+    const couplets = $getCouplets(block);
+    const anchorNode = $isRangeSelection(selection) ? selection.anchor.getNode() : null;
+    const position = anchorNode ? $findCoupletPosition(couplets, anchorNode) : null;
+    const target = position ? couplets[position.coupletIndex] : couplets[couplets.length - 1];
+    if (!target)
+        return false;
+    if (couplets.length <= 1) {
+        block.remove();
+        return true;
+    }
+    const [a, b] = target;
+    const container = $findMatchingParent(a, $isLayoutContainerNode);
+    if (container)
+        container.remove();
+    else {
+        a.remove();
+        b.remove();
+    }
     return true;
 }
 /**
- * Backspace at the very start of an empty couplet's first misra removes the
- * whole block — the natural keystroke to try first, and otherwise there was
- * no way to get rid of an empty couplet created by mistake (its two misra
- * paragraphs each have their own default canBeEmpty, so Lexical's usual
- * "delete the empty block" handling never reaches the couplet itself).
- * Returns false for every other caret position, including a non-empty
- * couplet, so normal Backspace handling (e.g. deleting within text) proceeds.
+ * Backspace at the very start of an empty couplet removes just that
+ * couplet — merging back into the previous one's end, or (if it's the
+ * block's only couplet) removing the whole block, since an empty poetry
+ * section serves no purpose. Otherwise there was no way to get rid of an
+ * empty couplet created by mistake (its misra paragraphs each have their
+ * own default canBeEmpty, so Lexical's usual "delete the empty block"
+ * handling never reaches the couplet itself). Returns false for every
+ * other caret position, including a non-empty couplet, so normal Backspace
+ * handling (e.g. deleting within text) proceeds.
  */
 export function $deletePoetryOnBackspace() {
     const selection = $getSelection();
     if (!$isRangeSelection(selection) || !selection.isCollapsed())
         return false;
-    const couplet = $getPoetryBlockFromSelection();
-    if (!couplet)
-        return false;
-    const misras = $getMisraParagraphs(couplet);
-    const firstMisra = misras[0];
-    if (!firstMisra)
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
         return false;
-    if (misras.some((m) => !m.isEmpty()))
+    const couplets = $getCouplets(block);
+    const anchorNode = selection.anchor.getNode();
+    const position = $findCoupletPosition(couplets, anchorNode);
+    if (!position || position.misraIndex !== 0)
         return false;
+    const [firstMisra] = couplets[position.coupletIndex];
     const anchor = selection.anchor;
     const isAtStart = anchor.key === firstMisra.getKey() && anchor.offset === 0;
     if (!isAtStart)
         return false;
-    const previous = couplet.getPreviousSibling();
-    couplet.remove();
-    if ($isElementNode(previous))
-        previous.selectEnd();
+    const [a, b] = couplets[position.coupletIndex];
+    if (!a.isEmpty() || !b.isEmpty())
+        return false;
+    if (couplets.length <= 1) {
+        const previous = block.getPreviousSibling();
+        block.remove();
+        if ($isElementNode(previous))
+            previous.selectEnd();
+        return true;
+    }
+    const container = $findMatchingParent(a, $isLayoutContainerNode);
+    if (container)
+        container.remove();
+    else {
+        a.remove();
+        b.remove();
+    }
+    const remaining = $getCouplets(block);
+    const previousCouplet = remaining[position.coupletIndex - 1] ?? remaining[0];
+    previousCouplet?.[1].selectEnd();
     return true;
 }
 /**
- * Enter at the end of a couplet's last misra would otherwise land inside
- * ParagraphNode's own insertNewAfter — which inserts the new paragraph as a
- * sibling of the misra, i.e. still inside the couplet (or, for two-column,
- * inside its LayoutItemNode) — trapping the caret with no way to add a line
- * after the block. Handled here instead: a plain paragraph after the whole
- * couplet, focused. Returns false (let normal Enter handling proceed) for
- * every other caret position, including earlier in the couplet.
+ * Enter inside a poetry block never grows a couplet past its fixed two
+ * misras. The block's *last* couplet being completely empty is always the
+ * exit trigger, regardless of which of its two (both-empty) misras the
+ * caret happens to be on — pressing Enter once on a non-empty last couplet
+ * appends a fresh empty one to continue into ("new couplet after last"),
+ * and pressing Enter again on that still-untouched couplet exits ("double
+ * enter to exit the block"): the same empty-item convention most editors
+ * use for lists. Outside that case: pressed in a couplet's first misra,
+ * Enter moves the caret to the second (already there; nothing inserted —
+ * this is what stops ParagraphNode's default insertNewAfter from growing
+ * the couplet, which would otherwise insert the new paragraph as a sibling
+ * of wherever the caret was, i.e. still inside the couplet); pressed in
+ * the last misra of a couplet that isn't the block's last, it moves to the
+ * next couplet's first misra.
  */
 export function $exitPoetryOnEnter() {
     const selection = $getSelection();
     if (!$isRangeSelection(selection) || !selection.isCollapsed())
         return false;
-    const couplet = $getPoetryBlockFromSelection();
-    if (!couplet)
-        return false;
-    const misras = $getMisraParagraphs(couplet);
-    const lastMisra = misras[misras.length - 1];
-    if (!lastMisra)
+    const block = $getPoetryBlockFromSelection();
+    if (!block)
         return false;
-    const anchor = selection.anchor;
-    const lastDesc = lastMisra.getLastDescendant();
-    const isAtEnd = lastDesc ? anchor.key === lastDesc.getKey() && anchor.offset === lastDesc.getTextContentSize() : anchor.key === lastMisra.getKey();
-    if (!isAtEnd)
+    const couplets = $getCouplets(block);
+    const position = $findCoupletPosition(couplets, selection.anchor.getNode());
+    if (!position)
         return false;
-    // $ensureTrailingParagraph already guarantees one after every couplet —
-    // reuse it rather than stacking a new empty paragraph on repeated Enters.
-    const existing = couplet.getNextSibling();
-    const paragraph = $isParagraphNode(existing) ? existing : $createParagraphNode();
-    if (paragraph !== existing)
-        couplet.insertAfter(paragraph);
-    paragraph.select();
+    const { coupletIndex, misraIndex } = position;
+    const [a, b] = couplets[coupletIndex];
+    const isLastCouplet = coupletIndex === couplets.length - 1;
+    const coupletEmpty = a.isEmpty() && b.isEmpty();
+    if (isLastCouplet && coupletEmpty) {
+        // Drop the couplet we ourselves auto-created on the previous Enter —
+        // unless it's the block's only couplet, in which case leave the
+        // section as the user's (empty) content rather than deleting it.
+        if (couplets.length > 1) {
+            const container = $findMatchingParent(a, $isLayoutContainerNode);
+            if (container)
+                container.remove();
+            else {
+                a.remove();
+                b.remove();
+            }
+        }
+        const existingNext = block.getNextSibling();
+        const paragraph = $isParagraphNode(existingNext) ? existingNext : $createParagraphNode();
+        if (paragraph !== existingNext)
+            block.insertAfter(paragraph);
+        paragraph.select();
+        return true;
+    }
+    if (misraIndex === 0) {
+        b.selectEnd();
+        return true;
+    }
+    if (!isLastCouplet) {
+        couplets[coupletIndex + 1][0].selectEnd();
+        return true;
+    }
+    const [newA] = $appendCoupletTo(block);
+    newA.selectStart();
     return true;
 }

package/dist/theme/editor.css

@@ -406,13 +406,18 @@
 
 /* Misra lines sit tight against each other within a couplet — the generic
    .likhari-paragraph margin would otherwise add the same gap between a
-   couplet's own two lines as between separate couplets, losing the pairing
-   entirely. The couplet's own margin-bottom (above) is the only gap that
-   should read as "extra space", and it falls after every second line. */
+   couplet's own two lines as between separate couplets within the same
+   block, losing the pairing entirely. Re-added below on every *second*
+   line (nth-child(2n)) — one couplet's worth of lines — so the extra space
+   falls after every couplet, not after every single line. */
 .likhari-poetry .likhari-paragraph {
   margin: 0;
 }
 
+.likhari-poetry--single .likhari-paragraph:nth-child(2n):not(:last-child) {
+  margin-bottom: 1em;
+}
+
 .likhari-poetry--two-column .likhari-layout-container {
   margin: 0;
   /* No grid gap — the divider below sits exactly on the track boundary, so
@@ -421,6 +426,12 @@
   gap: 0;
 }
 
+/* One row per couplet in two-column layout — same "extra space after every
+   couplet" rhythm as the single-column rule above. */
+.likhari-poetry--two-column .likhari-layout-container:not(:last-child) {
+  margin-bottom: 1em;
+}
+
 .likhari-poetry--two-column .likhari-layout-item {
   text-align: inherit;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inshapardaz/likhari-react",
-  "version": "0.1.18-dev.148",
+  "version": "0.1.18-dev.152",
   "description": "React implementation of the Likhari editor, built on @lexical/react.",
   "license": "MIT",
   "repository": {