@danxbot/ui 7.7.1 → 7.7.2

package/dist/types/lib/markdown/commands.d.ts

@@ -87,6 +87,14 @@ export declare function insertLink(href?: string, title?: string): Command;
  * to do nothing at all. Choosing a picture is the editor's job (its file
  * picker), so a command is only ever asked to write one that exists. The caret
  * lands after the image, where the next keystroke belongs.
+ *
+ * NEVER LANDS INSIDE CODE (DX-3140). This is public API (`src/index.ts`), a
+ * separate path from `ImagePipeline.insert` that a consumer can call directly
+ * against a selection with no idea what it currently contains — so it is
+ * exactly as able to write a dead `![](…)` into a fence or a span as a paste
+ * ever was. `enclosingCode` + `reshapeForCodeBoundary` (`images.ts`) are the
+ * SAME functions the pipeline uses for the same reason there, redirecting
+ * the insertion to land just past the code instead of inside it.
  */
 export declare function insertImage(src: string, alt?: string): Command;
 export interface TableSpan {

package/dist/types/lib/markdown/images.d.ts

@@ -1,3 +1,4 @@
+import { type Projection } from "./project";
 /** An image whose picture exists only in this page's memory. */
 export interface UnstoredImage {
     /** The `blob:` URL exactly as the source spells it. */
@@ -66,3 +67,55 @@ export interface Substitution {
  * INSIDE a replaced URL lands at the end of its replacement.
  */
 export declare function substituteAll(source: string, from: string, to: string): Substitution | null;
+/** The innermost code construct containing an offset — see `enclosingCode`. */
+export interface CodeConstruct {
+    end: number;
+    block: boolean;
+}
+/**
+ * The innermost code construct — fenced block, indented block, or inline span
+ * — containing `offset`, or null when `offset` sits in ordinary prose.
+ *
+ * DX-3140: read from the PROJECTION, the same source `marksAt`/`constructAt`
+ * in `convert.ts` use, rather than re-deriving fence syntax with a second
+ * regex — `blockAt`'s own `fenceAround` regex only ever recognises a FENCED
+ * block, so it would miss an indented one entirely, and every code kind here
+ * (fenced, indented, span) shares exactly one frame shape either way: the
+ * parser has already decided the boundary in every case a hand-rolled pattern
+ * gets wrong. Boundaries are inclusive on both ends, matching `marksAt` — a
+ * caret at either edge still reads as inside. When several code frames
+ * contain `offset` (a nested case the grammar does not produce today), the
+ * outermost one wins, so the image lands past all of them, not between two.
+ *
+ * SHARED, not private to the image pipeline: `insertImage` below is public
+ * API (`src/index.ts`), so a consumer calling it directly with a selection
+ * inside a code construct is exactly as able to write dead `![](…)` text into
+ * code as a paste ever was — the ONE check has to live somewhere both paths
+ * reach, not be re-derived per caller.
+ */
+export declare function enclosingCode(projection: Projection, offset: number): CodeConstruct | null;
+/**
+ * The text to actually write at `at` when it sits at the boundary of a code
+ * BLOCK (fenced or indented) — reshaped so it lands cleanly outside it.
+ *
+ * CALLERS MUST PASS THE SAME `at` THEY ACTUALLY SPLICE AT, and nothing else —
+ * this was a real bug (DX-3140 code review, round 1): reading the boundary
+ * characters from `enclosingCode`'s raw `end` while splicing at a DIFFERENT,
+ * caret-map-snapped offset meant the two could disagree, most detectably when
+ * `nearestStop` ever moved the insertion point off `end`. There being exactly
+ * ONE offset in this function's signature makes that class of drift
+ * impossible to reintroduce by construction, rather than by convention.
+ *
+ * A BLOCK FRAME ALREADY OWNS ITS OWN TRAILING NEWLINE, when one exists (`at`
+ * sits at the START of the next line, not at the fence's last backtick) — so
+ * blindly prefixing "\n\n" would stack a THIRD newline on top of the one
+ * already there, splitting the image from the code by a full extra blank
+ * line no author asked for. Reading what is already on each side of `at` and
+ * adding only what is missing keeps it to exactly one blank line before the
+ * image, and puts it on its own line after, whatever originally followed the
+ * block (nothing, a line right away, or an existing blank line of its own).
+ *
+ * A SPAN NEEDS NO RESHAPING — it just continues the line it was on — so this
+ * is only ever called for `enclosingCode(...).block === true`.
+ */
+export declare function reshapeForCodeBoundary(source: string, at: number, text: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danxbot/ui",
-  "version": "7.7.1",
+  "version": "7.7.2",
   "type": "module",
   "description": "Danxbot — a domain-agnostic React design system with motion as a first-class primitive.",
   "license": "MIT",