@unfold-mdx/react 0.0.1

package/dist/diff/index.cjs

@@ -0,0 +1,248 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/diff/index.ts
+var diff_exports = {};
+__export(diff_exports, {
+  codeDiff: () => codeDiff,
+  sentenceDiff: () => sentenceDiff,
+  tokenize: () => tokenize,
+  tokenizeCodeLine: () => tokenizeCodeLine,
+  tokenizeLines: () => tokenizeLines
+});
+module.exports = __toCommonJS(diff_exports);
+
+// src/diff/tokenize.ts
+function tokenize(text) {
+  if (!text) {
+    return [];
+  }
+  const splitRegex = /(?<=(?:(?<!\.)\.(?!\.)|[!?]))(?=\s|$)/;
+  return text.split(splitRegex).map((token) => token.trim()).filter((token) => token.length > 0);
+}
+
+// src/diff/sentenceDiff.ts
+var import_diff_match_patch = require("diff-match-patch");
+function sentenceDiff(prev, next) {
+  const prevSentences = tokenize(prev);
+  const nextSentences = tokenize(next);
+  const sentenceToChar = /* @__PURE__ */ new Map();
+  const charToSentence = [];
+  function getCharForSentence(sentence) {
+    let char = sentenceToChar.get(sentence);
+    if (char === void 0) {
+      const code = charToSentence.length;
+      char = String.fromCharCode(code);
+      sentenceToChar.set(sentence, char);
+      charToSentence.push(sentence);
+    }
+    return char;
+  }
+  const prevChars = prevSentences.map(getCharForSentence).join("");
+  const nextChars = nextSentences.map(getCharForSentence).join("");
+  const dmp = new import_diff_match_patch.diff_match_patch();
+  const diffs = dmp.diff_main(prevChars, nextChars);
+  dmp.diff_cleanupSemantic(diffs);
+  const result = [];
+  let i = 0;
+  while (i < diffs.length) {
+    const [op, text] = diffs[i];
+    if (op === 0) {
+      for (let j = 0; j < text.length; j++) {
+        result.push({
+          kind: "equal",
+          sentence: charToSentence[text.charCodeAt(j)]
+        });
+      }
+      i++;
+    } else if (op === -1 && i + 1 < diffs.length && diffs[i + 1][0] === 1) {
+      const deleteText = text;
+      const insertText = diffs[i + 1][1];
+      const deleteLen = deleteText.length;
+      const insertLen = insertText.length;
+      const minLen = Math.min(deleteLen, insertLen);
+      for (let j = 0; j < minLen; j++) {
+        result.push({
+          kind: "modified",
+          before: charToSentence[deleteText.charCodeAt(j)],
+          after: charToSentence[insertText.charCodeAt(j)]
+        });
+      }
+      for (let j = minLen; j < deleteLen; j++) {
+        result.push({
+          kind: "removed",
+          sentence: charToSentence[deleteText.charCodeAt(j)]
+        });
+      }
+      for (let j = minLen; j < insertLen; j++) {
+        result.push({
+          kind: "added",
+          sentence: charToSentence[insertText.charCodeAt(j)]
+        });
+      }
+      i += 2;
+    } else if (op === -1) {
+      for (let j = 0; j < text.length; j++) {
+        result.push({
+          kind: "removed",
+          sentence: charToSentence[text.charCodeAt(j)]
+        });
+      }
+      i++;
+    } else if (op === 1) {
+      for (let j = 0; j < text.length; j++) {
+        result.push({
+          kind: "added",
+          sentence: charToSentence[text.charCodeAt(j)]
+        });
+      }
+      i++;
+    }
+  }
+  return result;
+}
+
+// src/diff/codeTokenize.ts
+function tokenizeLines(code) {
+  if (code === "") return [];
+  return code.split(/\r?\n/);
+}
+function tokenizeCodeLine(line) {
+  if (line === "") return [];
+  const regex = /([a-zA-Z0-9_]+|\s+|[^a-zA-Z0-9_\s])/g;
+  const tokens = [];
+  let match;
+  while ((match = regex.exec(line)) !== null) {
+    if (match[0].length > 0) {
+      tokens.push(match[0]);
+    }
+  }
+  return tokens;
+}
+
+// src/diff/codeDiff.ts
+var import_diff_match_patch2 = require("diff-match-patch");
+function codeDiff(prev, next) {
+  if (prev === "" && next !== "") {
+    return tokenizeLines(next).map((line) => ({
+      kind: "added",
+      tokens: tokenizeCodeLine(line).map((t) => ({ kind: "added", text: t }))
+    }));
+  }
+  const prevLines = tokenizeLines(prev);
+  const nextLines = tokenizeLines(next);
+  const lineToChar = /* @__PURE__ */ new Map();
+  const charToLine = [];
+  function getCharForLine(line) {
+    let char = lineToChar.get(line);
+    if (char === void 0) {
+      const code = charToLine.length;
+      char = String.fromCharCode(code);
+      lineToChar.set(line, char);
+      charToLine.push(line);
+    }
+    return char;
+  }
+  const prevChars = prevLines.map(getCharForLine).join("");
+  const nextChars = nextLines.map(getCharForLine).join("");
+  const dmp = new import_diff_match_patch2.diff_match_patch();
+  const diffs = dmp.diff_main(prevChars, nextChars);
+  dmp.diff_cleanupSemantic(diffs);
+  const result = [];
+  let i = 0;
+  while (i < diffs.length) {
+    const [op, text] = diffs[i];
+    if (op === 0) {
+      for (let j = 0; j < text.length; j++) {
+        result.push({
+          kind: "equal",
+          line: charToLine[text.charCodeAt(j)]
+        });
+      }
+      i++;
+    } else if (op === -1 && i + 1 < diffs.length && diffs[i + 1][0] === 1) {
+      const deleteText = text;
+      const insertText = diffs[i + 1][1];
+      const deleteLen = deleteText.length;
+      const insertLen = insertText.length;
+      const minLen = Math.min(deleteLen, insertLen);
+      for (let j = 0; j < minLen; j++) {
+        let getCharForToken2 = function(tok) {
+          let char = tokenToChar.get(tok);
+          if (char === void 0) {
+            const code = charToToken.length;
+            char = String.fromCharCode(code);
+            tokenToChar.set(tok, char);
+            charToToken.push(tok);
+          }
+          return char;
+        };
+        var getCharForToken = getCharForToken2;
+        const prevLine = charToLine[deleteText.charCodeAt(j)];
+        const nextLine = charToLine[insertText.charCodeAt(j)];
+        const prevTokens = tokenizeCodeLine(prevLine);
+        const nextTokens = tokenizeCodeLine(nextLine);
+        const tokenToChar = /* @__PURE__ */ new Map();
+        const charToToken = [];
+        const prevTokChars = prevTokens.map(getCharForToken2).join("");
+        const nextTokChars = nextTokens.map(getCharForToken2).join("");
+        const tokDiffs = dmp.diff_main(prevTokChars, nextTokChars);
+        dmp.diff_cleanupSemantic(tokDiffs);
+        const tokens = [];
+        for (let k = 0; k < tokDiffs.length; k++) {
+          const [tokOp, tokText] = tokDiffs[k];
+          if (tokOp === 0) {
+            for (let c = 0; c < tokText.length; c++) {
+              tokens.push({ kind: "equal", text: charToToken[tokText.charCodeAt(c)] });
+            }
+          } else if (tokOp === 1) {
+            for (let c = 0; c < tokText.length; c++) {
+              tokens.push({ kind: "added", text: charToToken[tokText.charCodeAt(c)] });
+            }
+          }
+        }
+        result.push({ kind: "changed", tokens });
+      }
+      for (let j = minLen; j < insertLen; j++) {
+        const line = charToLine[insertText.charCodeAt(j)];
+        const tokens = tokenizeCodeLine(line).map((t) => ({ kind: "added", text: t }));
+        result.push({ kind: "added", tokens });
+      }
+      i += 2;
+    } else if (op === -1) {
+      i++;
+    } else if (op === 1) {
+      for (let j = 0; j < text.length; j++) {
+        const line = charToLine[text.charCodeAt(j)];
+        const tokens = tokenizeCodeLine(line).map((t) => ({ kind: "added", text: t }));
+        result.push({ kind: "added", tokens });
+      }
+      i++;
+    }
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  codeDiff,
+  sentenceDiff,
+  tokenize,
+  tokenizeCodeLine,
+  tokenizeLines
+});

package/dist/diff/index.d.cts

@@ -0,0 +1,37 @@
+export { C as CodeLineDiff, a as CodeToken, c as codeDiff } from '../codeDiff-BVwZfdt9.cjs';
+
+/**
+ * Splits a prose string into an ordered array of sentence strings.
+ *
+ * Rules:
+ * - Split on '.', '!', '?' followed by whitespace or end-of-string.
+ * - Treat ellipsis ('...') as non-splitting.
+ * - Trim leading/trailing whitespace from each token; discard empty tokens.
+ * - Pure function — no side effects.
+ */
+declare function tokenize(text: string): string[];
+
+type SentenceDiff = {
+    kind: "equal";
+    sentence: string;
+} | {
+    kind: "added";
+    sentence: string;
+} | {
+    kind: "removed";
+    sentence: string;
+} | {
+    kind: "modified";
+    before: string;
+    after: string;
+};
+/**
+ * Given two consecutive full-snapshot strings, returns a structured diff
+ * describing which sentences are unchanged, added, removed, or modified.
+ */
+declare function sentenceDiff(prev: string, next: string): SentenceDiff[];
+
+declare function tokenizeLines(code: string): string[];
+declare function tokenizeCodeLine(line: string): string[];
+
+export { type SentenceDiff, sentenceDiff, tokenize, tokenizeCodeLine, tokenizeLines };

package/dist/diff/index.d.ts

@@ -0,0 +1,37 @@
+export { C as CodeLineDiff, a as CodeToken, c as codeDiff } from '../codeDiff-BVwZfdt9.js';
+
+/**
+ * Splits a prose string into an ordered array of sentence strings.
+ *
+ * Rules:
+ * - Split on '.', '!', '?' followed by whitespace or end-of-string.
+ * - Treat ellipsis ('...') as non-splitting.
+ * - Trim leading/trailing whitespace from each token; discard empty tokens.
+ * - Pure function — no side effects.
+ */
+declare function tokenize(text: string): string[];
+
+type SentenceDiff = {
+    kind: "equal";
+    sentence: string;
+} | {
+    kind: "added";
+    sentence: string;
+} | {
+    kind: "removed";
+    sentence: string;
+} | {
+    kind: "modified";
+    before: string;
+    after: string;
+};
+/**
+ * Given two consecutive full-snapshot strings, returns a structured diff
+ * describing which sentences are unchanged, added, removed, or modified.
+ */
+declare function sentenceDiff(prev: string, next: string): SentenceDiff[];
+
+declare function tokenizeLines(code: string): string[];
+declare function tokenizeCodeLine(line: string): string[];
+
+export { type SentenceDiff, sentenceDiff, tokenize, tokenizeCodeLine, tokenizeLines };

package/dist/diff/index.js

@@ -0,0 +1,14 @@
+import {
+  codeDiff,
+  sentenceDiff,
+  tokenize,
+  tokenizeCodeLine,
+  tokenizeLines
+} from "../chunk-OX5XKYQT.js";
+export {
+  codeDiff,
+  sentenceDiff,
+  tokenize,
+  tokenizeCodeLine,
+  tokenizeLines
+};