react-native-jet-markdown 0.2.0 → 0.2.2

package/cpp/tests/parser_tests.cpp

@@ -8,9 +8,6 @@
 #include <vector>
 
 #include "../core/AstJson.h"
-#include "../core/AstToMarkdown.h"
-#include "../core/EditorRuns.h"
-#include "../core/EditorText.h"
 #include "../core/Parser.h"
 
 namespace {
@@ -51,113 +48,6 @@ void expectNotContains(const char* name, const std::string& markdown, const std:
   }
 }
 
-// The round-trip law: parsing the serialized output must reproduce the
-// original AST exactly, even when the spelling normalizes.
-void expectRoundTrip(const char* name, const std::string& markdown) {
-  g_total++;
-  auto doc = jetmarkdown::parseMarkdown(markdown);
-  const std::string original = jetmarkdown::astToJson(doc->root);
-  const std::string serialized = jetmarkdown::astToMarkdown(doc->root);
-  auto reparsed = jetmarkdown::parseMarkdown(serialized);
-  const std::string actual = jetmarkdown::astToJson(reparsed->root);
-  if (actual != original) {
-    g_failures++;
-    std::printf(
-        "FAIL roundtrip %s\n  input:      %s\n  serialized: %s\n  expected:   %s\n  actual:     %s\n",
-        name, markdown.c_str(), serialized.c_str(), original.c_str(), actual.c_str());
-  }
-}
-
-void expectString(
-    const char* name, const std::string& actual, const std::string& expected) {
-  g_total++;
-  if (actual != expected) {
-    g_failures++;
-    std::printf("FAIL %s\n  expected: %s\n  actual:   %s\n",
-                name, expected.c_str(), actual.c_str());
-  }
-}
-
-// Canonical form: one maximal run per mark bit, so equivalent mark coverage
-// compares equal regardless of how runs were sliced or combined.
-std::string dumpStyled(const jetmarkdown::StyledText& styled) {
-  std::string out = "\"" + styled.text + "\"";
-  for (uint32_t bit = 1; bit <= jetmarkdown::MarkSubscript; bit <<= 1) {
-    std::vector<std::pair<uint32_t, uint32_t>> intervals;
-    for (const auto& run : styled.runs) {
-      if ((run.flags & bit) == 0 || run.start >= run.end) {
-        continue;
-      }
-      intervals.push_back({run.start, run.end});
-    }
-    std::sort(intervals.begin(), intervals.end());
-    for (size_t i = 0; i < intervals.size(); i++) {
-      auto [start, end] = intervals[i];
-      while (i + 1 < intervals.size() && intervals[i + 1].first <= end) {
-        end = std::max(end, intervals[++i].second);
-      }
-      out += " " + std::to_string(start) + ":" + std::to_string(end) + ":" +
-          std::to_string(bit);
-    }
-  }
-  return out;
-}
-
-std::string dumpEditor(const jetmarkdown::EditorDocument& document) {
-  std::string out = dumpStyled({document.text, document.runs});
-  out += " |";
-  for (const auto& line : document.lines) {
-    out += " " + std::to_string(static_cast<int>(line.type));
-    if (line.level != 0) {
-      out += "." + std::to_string(line.level);
-    }
-  }
-  for (const auto& link : document.links) {
-    out += " [" + std::to_string(link.start) + ":" + std::to_string(link.end) +
-        " " + link.url + "]";
-  }
-  return out;
-}
-
-// The editor round-trip law with blocks: text + runs + line blocks must
-// survive serialization to markdown and re-extraction unchanged.
-void expectEditorRoundTrip(
-    const char* name,
-    const std::string& text,
-    const std::vector<jetmarkdown::StyledRun>& runs,
-    const std::vector<jetmarkdown::EditorLine>& lines) {
-  g_total++;
-  const std::string markdown = jetmarkdown::markdownFromEditor(text, runs, lines);
-  const auto extracted = jetmarkdown::editorFromMarkdown(markdown);
-  const std::string expected = dumpEditor({text, runs, lines, {}});
-  const std::string actual = dumpEditor(extracted);
-  if (actual != expected) {
-    g_failures++;
-    std::printf(
-        "FAIL editor %s\n  serialized: %s\n  expected:   %s\n  actual:     %s\n",
-        name, markdown.c_str(), expected.c_str(), actual.c_str());
-  }
-}
-
-// The editor round-trip law: text + mark runs must survive serialization to
-// markdown and re-extraction unchanged.
-void expectStyledRoundTrip(
-    const char* name,
-    const std::string& text,
-    const std::vector<jetmarkdown::StyledRun>& runs) {
-  g_total++;
-  const std::string markdown = jetmarkdown::markdownFromStyledText(text, runs);
-  const auto extracted = jetmarkdown::styledTextFromMarkdown(markdown);
-  const std::string expected = dumpStyled({text, runs});
-  const std::string actual = dumpStyled(extracted);
-  if (actual != expected) {
-    g_failures++;
-    std::printf(
-        "FAIL styled %s\n  serialized: %s\n  expected:   %s\n  actual:     %s\n",
-        name, markdown.c_str(), expected.c_str(), actual.c_str());
-  }
-}
-
 } // namespace
 
 int main() {
@@ -337,82 +227,6 @@ int main() {
       "- a\n  - b",
       R"("type":"list")");
 
-  // --- Serializer round trips (AstToMarkdown) ---
-  expectRoundTrip("rt paragraph", "hello world");
-  expectRoundTrip("rt two paragraphs", "one\n\ntwo");
-  expectRoundTrip("rt soft break", "line one\nline two");
-  expectRoundTrip("rt hard break", "line one\\\nline two");
-  expectRoundTrip("rt headings", "# H1\n\n## H2\n\n###### H6");
-  expectRoundTrip("rt bold italic", "**bold** and _italic_ and **bold _nested_**");
-  expectRoundTrip("rt strikethrough", "~~gone~~ stays");
-  expectRoundTrip("rt spoiler", "both ||secret|| kinds >!hidden!< here");
-  expectRoundTrip("rt sup sub", "x^2^ and H~2~O and reddit ^word too");
-  expectRoundTrip("rt sup multiword", "reddit ^(multi word) form");
-  expectRoundTrip("rt inline code", "run `npm install` now");
-  expectRoundTrip("rt inline code with backticks", "a ``code `with` ticks`` b");
-  expectRoundTrip("rt link", "see [the docs](https://example.com) now");
-  expectRoundTrip("rt link with parens", "see [x](https://en.wikipedia.org/wiki/Bracket_(disambiguation))");
-  expectRoundTrip("rt mention", "ping [@ali](users://ali) in [#general](channels://general)");
-  expectRoundTrip("rt autolink", "visit https://example.com today");
-  {
-    // A link whose label equals its URL serializes as the bare URL (the
-    // permissive-autolink form), not the noisy [url](url) form.
-    auto doc = jetmarkdown::parseMarkdown("visit https://example.com today");
-    expectString("autolink serializes bare",
-                 jetmarkdown::astToMarkdown(doc->root),
-                 "visit https://example.com today\n");
-    auto labeled = jetmarkdown::parseMarkdown("[docs](https://example.com)");
-    expectString("labeled link keeps brackets",
-                 jetmarkdown::astToMarkdown(labeled->root),
-                 "[docs](https://example.com)\n");
-  }
-  expectRoundTrip("rt image", "![alt text](https://example.com/img.png)");
-  expectRoundTrip("rt quote", "> quoted **bold**\n>\n> second paragraph");
-  expectRoundTrip("rt nested quote content", "> outer\n>\n> - a\n> - b");
-  expectRoundTrip("rt code block", "```ts\nconst x = 1;\nconst y = \"two\";\n```");
-  expectRoundTrip("rt code block with backticks", "````\na ``` fence inside\n````");
-  expectRoundTrip("rt unordered list", "- one\n- two\n- three");
-  expectRoundTrip("rt ordered list", "1. first\n2. second");
-  expectRoundTrip("rt ordered list start", "5. five\n6. six");
-  expectRoundTrip("rt nested list", "- a\n  - a1\n  - a2\n- b");
-  expectRoundTrip("rt list with paragraphs", "- first para\n\n  second para\n- next item");
-  expectRoundTrip("rt table", "| A | B |\n|---|---|\n| 1 | 2 |");
-  expectRoundTrip("rt table alignment", "| L | C | R |\n|:--|:-:|--:|\n| a | b | c |");
-  expectRoundTrip("rt thematic break", "one\n\n---\n\ntwo");
-  expectRoundTrip("rt literal specials", "not *bold* stays\\* literal \\_x\\_ and \\`tick\\`");
-  expectRoundTrip("rt literal hash", "\\# not a heading");
-  expectRoundTrip("rt literal list", "1\\. not a list");
-  expectRoundTrip("rt literal pipe", "a \\| b");
-  expectRoundTrip("rt exclamation", "wow! and ![not image");
-  expectRoundTrip("rt mixed document",
-      "# Title\n\nIntro with **bold**, `code`, and [a link](https://x.dev).\n\n"
-      "> A quote\n\n- item one\n- item two\n\n```js\nconsole.log(1);\n```\n\n"
-      "| K | V |\n|---|---|\n| a | 1 |\n\n---\n\nThe ||end|| ^fin^");
-
-  // --- Escaped extension delimiters must stay literal through round trips
-  // (md4c strips backslashes before the inline-extension scanner runs; the
-  // preprocess entity rewrite + verbatim text nodes keep them de-fanged).
-  expectStyledRoundTrip("escape literal spoiler", "a ||spoiler|| b", {});
-  expectStyledRoundTrip("escape literal caret", "a^b c", {});
-  expectStyledRoundTrip("escape literal tilde pair", "a ~sub~ b", {});
-  expectStyledRoundTrip("escape literal strikethrough", "x ~~strike~~ y", {});
-  expectStyledRoundTrip("escape literal reddit spoiler", ">!hidden!< tail", {});
-  expectStyledRoundTrip("escape literal entity text", "use &#124; here", {});
-  expectStyledRoundTrip("escape literal angle autolink", "see <http://example.com> now", {});
-  expectStyledRoundTrip("escape leading spaces", "    indented text", {});
-  expectRoundTrip("escaped pipe still literal in backticks", "keep `a \\| b` code");
-
-  // --- Emphasis adjacency: stars must survive intraword adjacency and the
-  // 4+ star-run fallback must use flanking-legal underscores.
-  expectStyledRoundTrip("adjacent bold italic intraword", "XyZ",
-      {{0, 1, jetmarkdown::MarkBold}, {1, 2, jetmarkdown::MarkItalic}});
-  expectStyledRoundTrip("adjacent italic bold intraword", "XyZ",
-      {{0, 1, jetmarkdown::MarkItalic}, {1, 2, jetmarkdown::MarkBold}});
-
-  // --- Superscript content that fits neither caret form.
-  expectStyledRoundTrip("sup paren without space", "ab",
-      {{0, 2, jetmarkdown::MarkSuperscript}});
-
   // --- Hostile nesting must parse without blowing the stack (depth cap).
   {
     std::string hostile;
@@ -425,13 +239,6 @@ int main() {
     if (doc->root == nullptr) {
       g_failures++;
       std::printf("FAIL deep nesting parse\n");
-    } else {
-      // Serialization must also complete (bounded recursion).
-      const std::string out = jetmarkdown::astToMarkdown(doc->root);
-      if (out.empty()) {
-        g_failures++;
-        std::printf("FAIL deep nesting serialize\n");
-      }
     }
   }
 
@@ -448,215 +255,6 @@ int main() {
       "bad &#xD800; ref",
       "\xEF\xBF\xBD");
 
-  // --- Editor plain-text bridge (E1) ---
-  expectString(
-      "editor markdown from text",
-      jetmarkdown::markdownFromPlainText("hello\nworld"),
-      "hello\n\nworld\n");
-  expectString(
-      "editor text escapes literals",
-      jetmarkdown::markdownFromPlainText("**not bold** #tag"),
-      "\\*\\*not bold\\*\\* #tag\n");
-  expectString(
-      "editor text escapes line starts",
-      jetmarkdown::markdownFromPlainText("# not a heading\n1. not a list"),
-      "\\# not a heading\n\n1\\. not a list\n");
-  expectString(
-      "editor text stable round trip",
-      jetmarkdown::plainTextFromMarkdown(
-          jetmarkdown::markdownFromPlainText("line one\nline two")),
-      "line one\nline two");
-  expectString(
-      "editor setValue flattens structure",
-      jetmarkdown::plainTextFromMarkdown("# Title\n\nbody with **bold**\n\n- a\n- b"),
-      "Title\nbody with bold\na\nb");
-
-  // --- Editor styled runs (E2) ---
-  using jetmarkdown::MarkBold;
-  using jetmarkdown::MarkInlineCode;
-  using jetmarkdown::MarkItalic;
-  using jetmarkdown::MarkSpoiler;
-  using jetmarkdown::MarkStrikethrough;
-  using jetmarkdown::MarkSubscript;
-  using jetmarkdown::MarkSuperscript;
-
-  expectString(
-      "styled bold run",
-      jetmarkdown::markdownFromStyledText("hello world", {{0, 5, MarkBold}}),
-      "**hello** world\n");
-  expectString(
-      "styled code ignores nested marks",
-      jetmarkdown::markdownFromStyledText(
-          "x code y", {{2, 6, MarkInlineCode | MarkBold}}),
-      "x **`code`** y\n");
-  expectString(
-      "styled run clipped at newline",
-      jetmarkdown::markdownFromStyledText("ab\ncd", {{0, 5, MarkBold}}),
-      "**ab**\n\n**cd**\n");
-  expectString(
-      "styled marks escape content",
-      jetmarkdown::markdownFromStyledText("a*b", {{0, 3, MarkBold}}),
-      "**a\\*b**\n");
-
-  expectStyledRoundTrip("styled rt plain", "just text", {});
-  expectStyledRoundTrip("styled rt bold", "hello world", {{0, 5, MarkBold}});
-  expectStyledRoundTrip(
-      "styled rt every mark",
-      "abcdefg",
-      {{0, 1, MarkBold},
-       {1, 2, MarkItalic},
-       {2, 3, MarkStrikethrough},
-       {3, 4, MarkInlineCode},
-       {4, 5, MarkSpoiler},
-       {5, 6, MarkSuperscript},
-       {6, 7, MarkSubscript}});
-  expectStyledRoundTrip(
-      "styled rt overlap", "abc", {{0, 2, MarkBold}, {1, 3, MarkItalic}});
-  expectStyledRoundTrip(
-      "styled rt overlap glued tail",
-      "bcd",
-      {{0, 1, MarkBold}, {0, 2, MarkItalic}});
-  expectStyledRoundTrip(
-      "styled rt partial bold in code",
-      "x bc y",
-      {{2, 4, MarkInlineCode}, {3, 4, MarkBold}});
-  expectStyledRoundTrip(
-      "styled rt nested combo",
-      "bold and italic",
-      {{0, 15, MarkBold}, {9, 15, MarkItalic}});
-  expectStyledRoundTrip(
-      "styled rt multiline",
-      "first line\nsecond line",
-      {{0, 5, MarkBold}, {11, 17, MarkStrikethrough}});
-  expectStyledRoundTrip(
-      "styled rt emoji offsets", "\xF0\x9F\x98\x80 xy", {{3, 5, MarkBold}});
-  expectStyledRoundTrip(
-      "styled rt literal specials", "keep **this** literal", {{5, 13, MarkSpoiler}});
-  expectStyledRoundTrip(
-      "styled rt adjacent same mark merge", "abc", {{0, 2, MarkBold}, {2, 3, MarkBold}});
-
-  expectString(
-      "styled extraction",
-      dumpStyled(jetmarkdown::styledTextFromMarkdown("a **b** `c`")),
-      "\"a b c\" 2:3:1 4:5:8");
-
-  expectString(
-      "styled run trims edge spaces",
-      jetmarkdown::markdownFromStyledText("hi bold", {{2, 7, MarkBold}}),
-      "hi **bold**\n");
-  expectString(
-      "styled whitespace-only run drops",
-      jetmarkdown::markdownFromStyledText("a b", {{1, 2, MarkBold}}),
-      "a b\n");
-  // The pad space survives the code-span round trip (CommonMark strips one
-  // leading/trailing space pair), so the content keeps its edge spaces.
-  expectStyledRoundTrip(
-      "styled code run keeps spaces", "x y z", {{1, 4, MarkInlineCode}});
-
-  // --- Editor line blocks (E3) ---
-  using jetmarkdown::EditorBlockType;
-  using jetmarkdown::EditorLine;
-  const EditorLine P = {EditorBlockType::Paragraph, 0};
-  const EditorLine Q = {EditorBlockType::Quote, 0};
-  const EditorLine C = {EditorBlockType::Code, 0};
-  const EditorLine UL = {EditorBlockType::Bullet, 0};
-  const EditorLine OL = {EditorBlockType::Ordered, 0};
-
-  expectString(
-      "editor heading line",
-      jetmarkdown::markdownFromEditor(
-          "Title\nbody", {}, {{EditorBlockType::Heading, 2}, P}),
-      "## Title\n\nbody\n");
-  expectString(
-      "editor quote lines merge",
-      jetmarkdown::markdownFromEditor("a\nb", {}, {Q, Q}),
-      "> a\n>\n> b\n");
-  expectString(
-      "editor code lines merge raw",
-      jetmarkdown::markdownFromEditor(
-          "x = 1\ny *= 2", {{0, 5, MarkBold}}, {C, C}),
-      "```\nx = 1\ny *= 2\n```\n");
-  expectString(
-      "editor bullet list",
-      jetmarkdown::markdownFromEditor("a\nb", {}, {UL, UL}),
-      "- a\n- b\n");
-  expectString(
-      "editor ordered list",
-      jetmarkdown::markdownFromEditor("a\nb", {}, {OL, OL}),
-      "1. a\n2. b\n");
-  expectString(
-      "editor mixed blocks",
-      jetmarkdown::markdownFromEditor(
-          "Title\nintro\nitem", {{0, 5, MarkBold}},
-          {{EditorBlockType::Heading, 1}, P, UL}),
-      "# **Title**\n\nintro\n\n- item\n");
-
-  expectEditorRoundTrip("editor rt paragraphs", "one\ntwo", {}, {P, P});
-  expectEditorRoundTrip(
-      "editor rt heading levels",
-      "h1\nh6",
-      {},
-      {{EditorBlockType::Heading, 1}, {EditorBlockType::Heading, 6}});
-  expectEditorRoundTrip("editor rt quote", "quoted\nlines", {}, {Q, Q});
-  expectEditorRoundTrip(
-      "editor rt code block", "const x = 1;\nreturn x;", {}, {C, C});
-  expectEditorRoundTrip("editor rt bullets", "a\nb\nc", {}, {UL, UL, UL});
-  expectEditorRoundTrip("editor rt ordered", "a\nb", {}, {OL, OL});
-  expectEditorRoundTrip(
-      "editor rt marked list items",
-      "bold item\nplain",
-      {{0, 4, MarkBold}},
-      {UL, UL});
-  expectEditorRoundTrip(
-      "editor rt block transitions",
-      "head\npara\nquote\ncode\nitem one\nitem two\ntail",
-      {},
-      {{EditorBlockType::Heading, 3}, P, Q, C, UL, UL, P});
-
-  expectString(
-      "editor extraction with blocks",
-      dumpEditor(jetmarkdown::editorFromMarkdown(
-          "# Title\n\n- a\n- **b**\n\n> q\n\n```\nx\n```")),
-      "\"Title\na\nb\nq\nx\" 8:9:1 | 1.1 4 4 2 3");
-
-  // --- Editor links + mentions (E4) ---
-  expectString(
-      "editor link run serializes",
-      jetmarkdown::markdownFromEditor(
-          "visit the docs now", {}, {}, {{6, 14, "https://x.dev"}}),
-      "visit [the docs](https://x.dev) now\n");
-  expectString(
-      "editor mention link",
-      jetmarkdown::markdownFromEditor(
-          "ping @ali ok", {}, {}, {{5, 9, "users://ali"}}),
-      "ping [@ali](users://ali) ok\n");
-  expectString(
-      "editor marked link label",
-      jetmarkdown::markdownFromEditor(
-          "see docs here",
-          {{4, 8, jetmarkdown::MarkBold}},
-          {},
-          {{4, 8, "https://x.dev"}}),
-      "see [**docs**](https://x.dev) here\n");
-  expectString(
-      "editor link extraction",
-      dumpEditor(jetmarkdown::editorFromMarkdown(
-          "visit [the docs](https://x.dev) and [@ali](users://ali)")),
-      "\"visit the docs and @ali\" | 0 [6:14 https://x.dev] [19:23 users://ali]");
-  expectString(
-      "editor autolink extraction",
-      dumpEditor(jetmarkdown::editorFromMarkdown("see https://x.dev now")),
-      "\"see https://x.dev now\" | 0 [4:17 https://x.dev]");
-  expectString(
-      "editor link in list item",
-      jetmarkdown::markdownFromEditor(
-          "docs\nother",
-          {},
-          {{jetmarkdown::EditorBlockType::Bullet, 0},
-           {jetmarkdown::EditorBlockType::Bullet, 0}},
-          {{0, 4, "https://x.dev"}}),
-      "- [docs](https://x.dev)\n- other\n");
-
   std::printf("%d/%d passed\n", g_total - g_failures, g_total);
   return g_failures == 0 ? 0 : 1;
 }

package/cpp/tests/run_tests.sh

@@ -17,9 +17,6 @@ clang++ -std=c++17 -O1 -Wall -Wextra \
   ../core/InlineExtensions.cpp \
   ../core/AstJson.cpp \
   ../core/AstSerializer.cpp \
-  ../core/AstToMarkdown.cpp \
-  ../core/EditorText.cpp \
-  ../core/EditorRuns.cpp \
   "$BUILD_DIR/md4c.o"
 
 "$BUILD_DIR/parser_tests"

package/ios/JetMarkdownView.mm

@@ -34,6 +34,7 @@ using namespace facebook::react;
 
 static void JMDSetNeedsDisplayDeep(UIView *view);
 static CGRect JMDScreenFrameOfView(UIView *view);
+static BOOL JMDIsScrollInProgress(UIView *view);
 
 @implementation JetMarkdownView {
   NSString *_markdown;
@@ -166,10 +167,17 @@ static CGRect JMDScreenFrameOfView(UIView *view);
 }
 
 // Touches that do not start on an interactive range are never tracked, so
-// they cannot interfere with an ancestor scroll view's pan.
+// they cannot interfere with an ancestor scroll view's pan. A touch that
+// lands mid-scroll is a scroll-stopper, not a press (Pressable semantics) —
+// checked from the deepest content view so nested code/table scrollers and
+// the outer list both count.
 - (BOOL)gestureRecognizer:(UIGestureRecognizer *)recognizer
        shouldReceiveTouch:(UITouch *)touch {
-  return [self jmdIsInteractiveAtPoint:[touch locationInView:self]];
+  const CGPoint point = [touch locationInView:self];
+  if (![self jmdIsInteractiveAtPoint:point]) {
+    return NO;
+  }
+  return !JMDIsScrollInProgress([self jmdContentViewAtPoint:point inView:self]);
 }
 
 // Non-interactive points fall through to ancestors so a wrapping pressable
@@ -182,9 +190,32 @@ static CGRect JMDScreenFrameOfView(UIView *view);
   if (result == self && ![self jmdIsInteractiveAtPoint:point]) {
     return nil;
   }
+  // Mid-scroll, an interactive point is not claimed either: hit-testing runs
+  // before the touch is delivered, so isDecelerating is still reliable here
+  // (by shouldReceiveTouch: time the same touch may have already stopped the
+  // scroll). Falling through lets the ancestor scroll view take the touch
+  // and stop, exactly like tapping a Pressable during momentum.
+  if (result == self && JMDIsScrollInProgress(self)) {
+    return nil;
+  }
   return result;
 }
 
+// YES when any scroll view on the path from `view` up through the window is
+// being dragged or is decelerating — a press landing then must only stop
+// the scroll, never fire.
+static BOOL JMDIsScrollInProgress(UIView *view) {
+  for (UIView *ancestor = view; ancestor != nil; ancestor = ancestor.superview) {
+    if ([ancestor isKindOfClass:UIScrollView.class]) {
+      UIScrollView *scroll = (UIScrollView *)ancestor;
+      if (scroll.isDecelerating || scroll.isDragging) {
+        return YES;
+      }
+    }
+  }
+  return NO;
+}
+
 // Scrolling always wins: a drag that begins on a link still pans the list
 // (the tap/long-press simply fail on movement).
 - (BOOL)gestureRecognizer:(UIGestureRecognizer *)recognizer

package/lib/module/index.js

@@ -3,7 +3,5 @@
 /** biome-ignore-all lint/performance/noBarrelFile: go away */
 
 export { defaultStyles, mergeStyles } from "./defaultStyles.js";
-export { JetMarkdownEditor } from "./JetMarkdownEditor";
 export { JetMarkdownView } from "./JetMarkdownView";
-export { useJetMarkdownEditor } from "./useJetMarkdownEditor.js";
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["defaultStyles","mergeStyles","JetMarkdownEditor","JetMarkdownView","useJetMarkdownEditor"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA;;AAEA,SAASA,aAAa,EAAEC,WAAW,QAAQ,oBAAiB;AAC5D,SAASC,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,eAAe,QAAQ,mBAAmB;AA6BnD,SAASC,oBAAoB,QAAQ,2BAAwB","ignoreList":[]}
+{"version":3,"names":["defaultStyles","mergeStyles","JetMarkdownView"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":";;AAAA;;AAEA,SAASA,aAAa,EAAEC,WAAW,QAAQ,oBAAiB;AAC5D,SAASC,eAAe,QAAQ,mBAAmB","ignoreList":[]}

package/lib/typescript/src/index.d.ts

@@ -1,7 +1,5 @@
 /** biome-ignore-all lint/performance/noBarrelFile: go away */
 export { defaultStyles, mergeStyles } from "./defaultStyles.js";
-export { JetMarkdownEditor } from "./JetMarkdownEditor";
 export { JetMarkdownView } from "./JetMarkdownView";
-export type { FontVariant, FontWeight, JetMarkdownEditorProps, JetMarkdownEditorRef, JetMarkdownViewProps, MarkdownContainerStyle, MarkdownDividerStyle, MarkdownEditorState, MarkdownHeadingLevel, MarkdownImageData, MarkdownImageEvent, MarkdownImageStyle, MarkdownInlineCodeStyle, MarkdownLayoutStyle, MarkdownListMarkerStyle, MarkdownListStyle, MarkdownMentionEvent, MarkdownMentionQueryEvent, MarkdownMentionStyle, MarkdownPasteEvent, MarkdownSelection, MarkdownSpoilerStyle, MarkdownStyles, MarkdownTableStyle, MarkdownTextStyle, MarkdownUrlEvent, } from "./types.js";
-export { useJetMarkdownEditor } from "./useJetMarkdownEditor.js";
+export type { FontVariant, FontWeight, JetMarkdownViewProps, MarkdownContainerStyle, MarkdownDividerStyle, MarkdownHeadingLevel, MarkdownImageData, MarkdownImageEvent, MarkdownImageStyle, MarkdownInlineCodeStyle, MarkdownLayoutStyle, MarkdownListMarkerStyle, MarkdownListStyle, MarkdownMentionStyle, MarkdownSpoilerStyle, MarkdownStyles, MarkdownTableStyle, MarkdownTextStyle, MarkdownUrlEvent, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,8DAA8D;AAE9D,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAiB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EACV,WAAW,EACX,UAAU,EACV,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,mBAAmB,EACnB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,kBAAkB,EAClB,iBAAiB,EACjB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAS,CAAC;AACjB,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAAA,8DAA8D;AAE9D,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,oBAAiB,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EACV,WAAW,EACX,UAAU,EACV,oBAAoB,EACpB,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,mBAAmB,EACnB,uBAAuB,EACvB,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAS,CAAC"}

package/lib/typescript/src/types.d.ts

@@ -195,10 +195,6 @@ export interface MarkdownContainerStyle extends MarkdownTextStyle {
     backgroundColor?: ColorValue;
     /** Vertical spacing between blocks; overrides `styles.gap`. */
     gap?: number;
-    /**
-     * Editor: caps autogrow — past this height the editor scrolls
-     * internally like a textarea. Viewer: plain layout clamp.
-     */
     maxHeight?: number;
     padding?: number;
     paddingBottom?: number;
@@ -208,129 +204,6 @@ export interface MarkdownContainerStyle extends MarkdownTextStyle {
     paddingTop?: number;
     paddingVertical?: number;
 }
-/** Formatting active at the cursor / selection. */
-export interface MarkdownEditorState {
-    /** 0 = no heading. */
-    headingLevel: number;
-    isBlockQuote: boolean;
-    isBold: boolean;
-    isCodeBlock: boolean;
-    isInlineCode: boolean;
-    isItalic: boolean;
-    isOrderedList: boolean;
-    isSpoiler: boolean;
-    isStrikethrough: boolean;
-    isSubscript: boolean;
-    isSuperscript: boolean;
-    isUnorderedList: boolean;
-}
-export interface MarkdownSelection {
-    end: number;
-    start: number;
-}
-export interface MarkdownMentionEvent {
-    trigger: string;
-}
-export interface MarkdownMentionQueryEvent {
-    query: string;
-    trigger: string;
-}
-/**
- * Paste payload. `text` is present when the clipboard has text (parsed as
- * markdown and inserted by default); `images` when it has images (reported
- * only, never auto-inserted). `preventDefault()` suppresses the default
- * text insertion.
- */
-export interface MarkdownPasteEvent {
-    images?: MarkdownImageData[];
-    preventDefault(): void;
-    text?: string;
-}
-export interface JetMarkdownEditorRef {
-    blur(): void;
-    focus(): void;
-    /** Resolves the markdown as of the latest edit. */
-    getMarkdown(): Promise<string>;
-    /**
-     * Links the selection to `url`; with a collapsed cursor, inserts `label`
-     * (or the URL itself) as linked text.
-     */
-    insertLink(url: string, label?: string): void;
-    /** Parses `markdown` and inserts it at the cursor (or over the selection). */
-    insertMarkdown(markdown: string): void;
-    /**
-     * Inserts an atomic mention token (`trigger + label`, e.g. `@ali`)
-     * linked to `url` (an app scheme like `users://ali`), replacing any
-     * active mention query.
-     */
-    insertMention(trigger: string, label: string, url: string): void;
-    /** Removes the link covering the selection or cursor. */
-    removeLink(): void;
-    setSelection(start: number, end: number): void;
-    /** Replaces the content; the value is parsed as markdown. */
-    setValue(markdown: string): void;
-    /** Block toggles apply to every line the selection touches. */
-    toggleBlockQuote(): void;
-    /**
-     * Each inline toggle applies to the selection, or arms/disarms the mark
-     * for text typed at the collapsed cursor.
-     */
-    toggleBold(): void;
-    toggleCode(): void;
-    toggleCodeBlock(): void;
-    /** Toggles the heading level (1-6) on the selected lines. */
-    toggleHeading(level: number): void;
-    toggleItalic(): void;
-    toggleOrderedList(): void;
-    toggleSpoiler(): void;
-    toggleStrikethrough(): void;
-    toggleSubscript(): void;
-    toggleSuperscript(): void;
-    toggleUnorderedList(): void;
-}
-export interface JetMarkdownEditorProps {
-    /** Scale text with the system font size setting. Defaults to true. */
-    allowFontScaling?: boolean;
-    autoCapitalize?: "none" | "sentences" | "words" | "characters";
-    autoCorrect?: boolean;
-    autoFocus?: boolean;
-    /**
-     * Caret color. On iOS the caret and selection share one tint, so
-     * `selectionColor` wins when both are set. Android 10+ only. Platform
-     * colors (`PlatformColor`, `DynamicColorIOS`) are supported.
-     */
-    cursorColor?: ColorValue;
-    /** Initial markdown content, applied once. */
-    defaultValue?: string;
-    editable?: boolean;
-    /** Trigger characters (e.g. '@', '#') that begin a mention. */
-    mentionTriggers?: string[];
-    multiline?: boolean;
-    onBlur?: () => void;
-    onChangeMarkdown?: (markdown: string) => void;
-    onChangeSelection?: (selection: MarkdownSelection) => void;
-    onChangeState?: (state: MarkdownEditorState) => void;
-    onChangeText?: (text: string) => void;
-    onFocus?: () => void;
-    onLinkDetected?: (event: MarkdownUrlEvent) => void;
-    onMentionChange?: (event: MarkdownMentionQueryEvent) => void;
-    onMentionEnd?: (event: MarkdownMentionEvent) => void;
-    onMentionStart?: (event: MarkdownMentionEvent) => void;
-    onPaste?: (event: MarkdownPasteEvent) => void;
-    placeholder?: string;
-    placeholderTextColor?: ColorValue;
-    scrollEnabled?: boolean;
-    /**
-     * Selection highlight color. On iOS this also tints the caret (UIKit
-     * shares one tint). Platform colors (`PlatformColor`, `DynamicColorIOS`)
-     * are supported.
-     */
-    selectionColor?: ColorValue;
-    /** Same container style contract as the viewer. */
-    style?: StyleProp<MarkdownContainerStyle>;
-    /** Per-element markdown styles; shared shape with the viewer. */
-    styles?: MarkdownStyles;
-}
 export interface JetMarkdownViewProps {
     /** Scale text with the system font size setting. Defaults to true. */
     allowFontScaling?: boolean;