@carlonicora/nextjs-jsonapi 0.0.1

package/dist/chunk-2LM6LCJW.mjs

@@ -0,0 +1,1091 @@
+import {
+  __name
+} from "./chunk-PAWJFY3S.mjs";
+
+// src/utils/cn.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+__name(cn, "cn");
+
+// src/utils/compose-refs.ts
+import * as React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  }
+  if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+__name(setRef, "setRef");
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup === "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup === "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+__name(composeRefs, "composeRefs");
+function useComposedRefs(...refs) {
+  return React.useCallback(composeRefs(...refs), refs);
+}
+__name(useComposedRefs, "useComposedRefs");
+
+// src/utils/use-mobile.tsx
+import * as React2 from "react";
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React2.useState(void 0);
+  React2.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = /* @__PURE__ */ __name(() => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    }, "onChange");
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
+}
+__name(useIsMobile, "useIsMobile");
+
+// src/utils/date-formatter.ts
+var formatDate = /* @__PURE__ */ __name((eventDate, formatOption) => {
+  const browserLocale = navigator.language || "en-US";
+  const formatPart = /* @__PURE__ */ __name((date, options) => new Intl.DateTimeFormat(browserLocale, options).format(date), "formatPart");
+  const now = /* @__PURE__ */ new Date();
+  const diff = now.getTime() - eventDate.getTime();
+  if (formatOption === "default") {
+    if (diff < 24 * 60 * 60 * 1e3) formatOption = "timeSince";
+    else formatOption = "dateTime";
+  }
+  if (formatOption === "timeSince") {
+    const seconds = Math.floor(diff / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0) return `${days} days ago`;
+    if (hours > 0) return `${hours} hours ago`;
+    if (minutes > 0) return `${minutes} minutes ago`;
+    return `${seconds} seconds ago`;
+  }
+  const dateOptions = {
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit"
+  };
+  const timeOptions = {
+    hour: "2-digit",
+    minute: "2-digit"
+  };
+  switch (formatOption) {
+    case "date":
+      return formatPart(eventDate, dateOptions);
+    case "time":
+      return formatPart(eventDate, timeOptions);
+    case "dateTime":
+      return `${formatPart(eventDate, dateOptions)} ${formatPart(eventDate, timeOptions)}`;
+    default:
+      throw new Error("Invalid format option");
+  }
+}, "formatDate");
+
+// src/utils/exists.ts
+var exists = /* @__PURE__ */ __name((itemOrArray) => {
+  if (!itemOrArray) return false;
+  if (Array.isArray(itemOrArray)) {
+    return itemOrArray.length > 0;
+  }
+  return true;
+}, "exists");
+
+// src/utils/table-options.ts
+import { cloneElement, createElement, Fragment } from "react";
+var TableOptions = class {
+  static {
+    __name(this, "TableOptions");
+  }
+  _components;
+  _hasPermissionToModule;
+  constructor(hasPermissionToModule) {
+    this._hasPermissionToModule = hasPermissionToModule;
+    this._components = [];
+  }
+  addOption(component, module, action) {
+    if (!component || module && action && !this._hasPermissionToModule({ module, action })) return;
+    this._components.push(component);
+  }
+  getComponents() {
+    return this._components;
+  }
+  getOptions() {
+    if (this._components.length === 0) return null;
+    const response = this._components.map(
+      (option, index) => cloneElement(option, { key: option.key ?? index })
+    );
+    return createElement(Fragment, {}, response);
+  }
+};
+function getTableOptions(params) {
+  const tableOptions = new TableOptions(params.hasPermissionToModule);
+  params.options.forEach((option) => tableOptions.addOption(option.component, option.module, option.action));
+  return tableOptions.getOptions();
+}
+__name(getTableOptions, "getTableOptions");
+function getTableComponents(params) {
+  const tableOptions = new TableOptions(params.hasPermissionToModule);
+  params.options.forEach((option) => tableOptions.addOption(option.component, option.module, option.action));
+  return tableOptions.getComponents();
+}
+__name(getTableComponents, "getTableComponents");
+
+// src/utils/schemas/user.object.schema.ts
+import { z } from "zod";
+var userObjectSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  avatar: z.string().optional()
+});
+
+// src/utils/schemas/entity.object.schema.ts
+import { z as z2 } from "zod";
+var entityObjectSchema = z2.object({
+  id: z2.uuidv4(),
+  name: z2.string()
+});
+
+// src/utils/blocknote-diff.util.ts
+var BlockNoteDiffUtil = class {
+  static {
+    __name(this, "BlockNoteDiffUtil");
+  }
+  static DEFAULT_OPTIONS = {
+    ignoreIds: false,
+    compareContent: true,
+    similarityThreshold: 0.8
+  };
+  /**
+   * Compare two BlockNote documents and return diff result
+   */
+  static diff(originalBlocks = [], newBlocks = [], options = {}) {
+    const opts = { ...this.DEFAULT_OPTIONS, ...options };
+    const originalMap = /* @__PURE__ */ new Map();
+    const newMap = /* @__PURE__ */ new Map();
+    originalBlocks.forEach((block) => {
+      if (block.id) {
+        originalMap.set(block.id, block);
+      }
+    });
+    newBlocks.forEach((block) => {
+      if (block.id) {
+        newMap.set(block.id, block);
+      }
+    });
+    const diffBlocks = [];
+    const processedNewIds = /* @__PURE__ */ new Set();
+    for (const originalBlock of originalBlocks) {
+      const blockId = originalBlock.id;
+      const processId = blockId || crypto.randomUUID();
+      const newBlock = blockId ? newMap.get(blockId) : null;
+      if (!newBlock) {
+        const removedBlock = {
+          ...originalBlock,
+          id: processId,
+          diffType: "removed",
+          diffId: `removed-${processId}`
+        };
+        diffBlocks.push(removedBlock);
+      } else {
+        if (blockId) {
+          processedNewIds.add(blockId);
+        }
+        if (this.areBlocksEqual(originalBlock, newBlock, opts)) {
+          const unchangedBlock = {
+            ...newBlock,
+            diffType: "unchanged"
+          };
+          diffBlocks.push(unchangedBlock);
+        } else {
+          const wordDiffs = this.generateWordDiffs(originalBlock.content, newBlock.content, processId);
+          const modifiedBlock = {
+            ...newBlock,
+            diffType: "modified",
+            originalContent: originalBlock.content,
+            diffId: `modified-${processId}`,
+            wordDiffs
+          };
+          diffBlocks.push(modifiedBlock);
+        }
+      }
+    }
+    for (const newBlock of newBlocks) {
+      const blockId = newBlock.id;
+      if (blockId && processedNewIds.has(blockId)) continue;
+      const generatedId = blockId || crypto.randomUUID();
+      const addedBlock = {
+        ...newBlock,
+        id: generatedId,
+        diffType: "added",
+        diffId: `added-${generatedId}`
+      };
+      diffBlocks.push(addedBlock);
+    }
+    const sortedDiffBlocks = this.sortDiffBlocks(diffBlocks, originalBlocks, newBlocks);
+    return {
+      blocks: sortedDiffBlocks,
+      hasChanges: sortedDiffBlocks.some((block) => block.diffType !== "unchanged")
+    };
+  }
+  /**
+   * Compare two blocks for equality
+   */
+  static areBlocksEqual(block1, block2, options) {
+    if (block1.type !== block2.type) {
+      return false;
+    }
+    if (!this.deepEqual(block1.props, block2.props)) {
+      return false;
+    }
+    if (options.compareContent) {
+      if (!this.deepEqual(block1.content, block2.content)) {
+        return false;
+      }
+    }
+    const children1 = block1.children || [];
+    const children2 = block2.children || [];
+    if (children1.length !== children2.length) {
+      return false;
+    }
+    for (let i = 0; i < children1.length; i++) {
+      if (!this.areBlocksEqual(children1[i], children2[i], options)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Deep equality comparison for objects
+   */
+  static deepEqual(obj1, obj2) {
+    if (obj1 === obj2) return true;
+    if (obj1 == null || obj2 == null) return obj1 === obj2;
+    if (typeof obj1 !== typeof obj2) return false;
+    if (typeof obj1 !== "object") return obj1 === obj2;
+    if (Array.isArray(obj1) !== Array.isArray(obj2)) return false;
+    if (Array.isArray(obj1)) {
+      if (obj1.length !== obj2.length) return false;
+      for (let i = 0; i < obj1.length; i++) {
+        if (!this.deepEqual(obj1[i], obj2[i])) return false;
+      }
+      return true;
+    }
+    const keys1 = Object.keys(obj1);
+    const keys2 = Object.keys(obj2);
+    if (keys1.length !== keys2.length) return false;
+    for (const key of keys1) {
+      if (!keys2.includes(key)) return false;
+      if (!this.deepEqual(obj1[key], obj2[key])) return false;
+    }
+    return true;
+  }
+  /**
+   * Sort diff blocks to maintain logical order
+   */
+  static sortDiffBlocks(diffBlocks, originalBlocks, newBlocks) {
+    const originalPositions = /* @__PURE__ */ new Map();
+    const newPositions = /* @__PURE__ */ new Map();
+    originalBlocks.forEach((block, index) => {
+      if (block.id) {
+        originalPositions.set(block.id, index);
+      }
+    });
+    newBlocks.forEach((block, index) => {
+      if (block.id) {
+        newPositions.set(block.id, index);
+      }
+    });
+    return diffBlocks.sort((a, b) => {
+      const aId = a.id;
+      const bId = b.id;
+      if (!aId || !bId) return 0;
+      const aPos = newPositions.get(aId) ?? originalPositions.get(aId) ?? Infinity;
+      const bPos = newPositions.get(bId) ?? originalPositions.get(bId) ?? Infinity;
+      return aPos - bPos;
+    });
+  }
+  /**
+   * Calculate similarity between two text contents
+   */
+  static calculateSimilarity(content1, content2) {
+    if (!content1 || !content2) return 0;
+    const text1 = this.extractTextFromContent(content1);
+    const text2 = this.extractTextFromContent(content2);
+    if (text1 === text2) return 1;
+    if (!text1 || !text2) return 0;
+    const maxLength = Math.max(text1.length, text2.length);
+    const distance = this.levenshteinDistance(text1, text2);
+    return 1 - distance / maxLength;
+  }
+  /**
+   * Extract plain text from BlockNote content array
+   */
+  static extractTextFromContent(content) {
+    if (!Array.isArray(content)) return "";
+    return content.map((item) => {
+      if (item.type === "text") {
+        return item.text || "";
+      }
+      return "";
+    }).join("");
+  }
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  static levenshteinDistance(str1, str2) {
+    const matrix = Array(str2.length + 1).fill(null).map(() => Array(str1.length + 1).fill(null));
+    for (let i = 0; i <= str1.length; i++) {
+      matrix[0][i] = i;
+    }
+    for (let j = 0; j <= str2.length; j++) {
+      matrix[j][0] = j;
+    }
+    for (let j = 1; j <= str2.length; j++) {
+      for (let i = 1; i <= str1.length; i++) {
+        const substitutionCost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+        matrix[j][i] = Math.min(
+          matrix[j][i - 1] + 1,
+          // deletion
+          matrix[j - 1][i] + 1,
+          // insertion
+          matrix[j - 1][i - 1] + substitutionCost
+          // substitution
+        );
+      }
+    }
+    return matrix[str2.length][str1.length];
+  }
+  /**
+   * Generate word-level diffs between two content arrays
+   */
+  static generateWordDiffs(originalContent, newContent, blockId) {
+    const originalText = this.extractTextFromContent(originalContent || []);
+    const newText = this.extractTextFromContent(newContent || []);
+    if (!originalText && !newText) return [];
+    if (!originalText) {
+      return newText.split(/\s+/).filter((word) => word.trim()).map((word, index) => ({
+        type: "added",
+        text: word,
+        diffId: `${blockId}-add-${index}`,
+        accepted: false,
+        rejected: false
+      }));
+    }
+    if (!newText) {
+      return originalText.split(/\s+/).filter((word) => word.trim()).map((word, index) => ({
+        type: "removed",
+        text: word,
+        diffId: `${blockId}-remove-${index}`,
+        accepted: false,
+        rejected: false
+      }));
+    }
+    return this.diffWords(originalText, newText, blockId);
+  }
+  /**
+   * Perform word-level diff using word-only approach (no space tokenization)
+   */
+  static diffWords(text1, text2, blockId) {
+    const words1 = text1.split(/\s+/).filter((word) => word.length > 0);
+    const words2 = text2.split(/\s+/).filter((word) => word.length > 0);
+    const diffs = this.myersDiff(words1, words2);
+    const consolidatedDiffs = this.consolidateAdjacentChanges(diffs);
+    const result = [];
+    let diffIndex = 0;
+    for (let i = 0; i < consolidatedDiffs.length; i++) {
+      const diff = consolidatedDiffs[i];
+      const isLastDiff = i === consolidatedDiffs.length - 1;
+      switch (diff.type) {
+        case "equal":
+          result.push({
+            type: "unchanged",
+            text: diff.value,
+            diffId: `${blockId}-unchanged-${diffIndex++}`,
+            accepted: true,
+            rejected: false
+          });
+          if (!isLastDiff) {
+            result.push({
+              type: "unchanged",
+              text: " ",
+              diffId: `${blockId}-space-${diffIndex++}`,
+              accepted: true,
+              rejected: false
+            });
+          }
+          break;
+        case "delete":
+          if (diff.consolidated) {
+            const nextDiff = i + 1 < consolidatedDiffs.length ? consolidatedDiffs[i + 1] : null;
+            const isConsolidatedReplacement = nextDiff && nextDiff.type === "insert" && nextDiff.consolidated;
+            if (isConsolidatedReplacement) {
+              const replacementId = `${blockId}-replace-${diffIndex++}`;
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              result.push({
+                type: "added",
+                text: nextDiff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              i++;
+              if (i < consolidatedDiffs.length - 1) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            } else {
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: `${blockId}-remove-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          } else {
+            const nextDiff = i + 1 < consolidatedDiffs.length ? consolidatedDiffs[i + 1] : null;
+            const isReplacement = nextDiff && nextDiff.type === "insert" && this.areWordsSimilar(diff.value, nextDiff.value);
+            if (isReplacement) {
+              const replacementId = `${blockId}-replace-${diffIndex++}`;
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              result.push({
+                type: "added",
+                text: nextDiff.value,
+                diffId: replacementId,
+                accepted: false,
+                rejected: false
+              });
+              i++;
+              if (i < consolidatedDiffs.length - 1) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            } else {
+              result.push({
+                type: "removed",
+                text: diff.value,
+                diffId: `${blockId}-remove-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          }
+          break;
+        case "insert":
+          if (diff.consolidated) {
+            const prevDiff = i > 0 ? consolidatedDiffs[i - 1] : null;
+            const wasProcessedAsConsolidatedReplacement = prevDiff && prevDiff.type === "delete" && prevDiff.consolidated;
+            if (!wasProcessedAsConsolidatedReplacement) {
+              result.push({
+                type: "added",
+                text: diff.value,
+                diffId: `${blockId}-add-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          } else {
+            const prevDiff = i > 0 ? consolidatedDiffs[i - 1] : null;
+            const wasProcessedAsReplacement = prevDiff && prevDiff.type === "delete" && this.areWordsSimilar(prevDiff.value, diff.value);
+            if (!wasProcessedAsReplacement) {
+              result.push({
+                type: "added",
+                text: diff.value,
+                diffId: `${blockId}-add-${diffIndex++}`,
+                accepted: false,
+                rejected: false
+              });
+              if (!isLastDiff) {
+                result.push({
+                  type: "unchanged",
+                  text: " ",
+                  diffId: `${blockId}-space-${diffIndex++}`,
+                  accepted: true,
+                  rejected: false
+                });
+              }
+            }
+          }
+          break;
+      }
+    }
+    return result;
+  }
+  /**
+  * Improved diff algorithm that better handles word insertions
+  * Uses a combination of LCS and heuristics to minimize false changes
+  */
+  static myersDiff(a, b) {
+    if (a.length === 0) {
+      return b.map((value) => ({ type: "insert", value }));
+    }
+    if (b.length === 0) {
+      return a.map((value) => ({ type: "delete", value }));
+    }
+    const dp = this.computeEditScript(a, b);
+    return this.reconstructDiff(a, b, dp);
+  }
+  /**
+   * Compute edit script using dynamic programming
+   */
+  static computeEditScript(a, b) {
+    const m = a.length;
+    const n = b.length;
+    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++) dp[i][0] = i;
+    for (let j = 0; j <= n; j++) dp[0][j] = j;
+    for (let i = 1; i <= m; i++) {
+      for (let j = 1; j <= n; j++) {
+        if (a[i - 1] === b[j - 1]) {
+          dp[i][j] = dp[i - 1][j - 1];
+        } else {
+          dp[i][j] = 1 + Math.min(
+            dp[i - 1][j],
+            // Delete from a
+            dp[i][j - 1],
+            // Insert into a
+            dp[i - 1][j - 1]
+            // Replace
+          );
+        }
+      }
+    }
+    return dp;
+  }
+  /**
+   * Reconstruct the actual diff from the DP table
+   */
+  static reconstructDiff(a, b, dp) {
+    const result = [];
+    let i = a.length;
+    let j = b.length;
+    while (i > 0 || j > 0) {
+      if (i > 0 && j > 0 && a[i - 1] === b[j - 1]) {
+        result.unshift({ type: "equal", value: a[i - 1] });
+        i--;
+        j--;
+      } else {
+        const deleteCost = i > 0 ? dp[i - 1][j] : Infinity;
+        const insertCost = j > 0 ? dp[i][j - 1] : Infinity;
+        const replaceCost = i > 0 && j > 0 ? dp[i - 1][j - 1] : Infinity;
+        const minCost = Math.min(deleteCost, insertCost, replaceCost);
+        if (minCost === insertCost && j > 0) {
+          result.unshift({ type: "insert", value: b[j - 1] });
+          j--;
+        } else if (minCost === deleteCost && i > 0) {
+          result.unshift({ type: "delete", value: a[i - 1] });
+          i--;
+        } else if (minCost === replaceCost && i > 0 && j > 0) {
+          if (this.areWordsSimilar(a[i - 1], b[j - 1])) {
+            result.unshift({ type: "insert", value: b[j - 1], sharedDiffId: true });
+            result.unshift({ type: "delete", value: a[i - 1], sharedDiffId: true });
+            i--;
+            j--;
+          } else {
+            result.unshift({ type: "insert", value: b[j - 1] });
+            j--;
+          }
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Consolidate adjacent changes to reduce fragmentation
+   * e.g., if we have: delete "Key", insert "Key!", delete "Challenges"
+   * We can consolidate this into: replace ["Key", "Challenges"] with ["Key!"]
+   */
+  static consolidateAdjacentChanges(diffs) {
+    const result = [];
+    let i = 0;
+    while (i < diffs.length) {
+      const current = diffs[i];
+      if (current.type === "equal") {
+        result.push(current);
+        i++;
+        continue;
+      }
+      const changeSequence = [];
+      let j = i;
+      while (j < diffs.length && diffs[j].type !== "equal") {
+        changeSequence.push(diffs[j]);
+        j++;
+      }
+      if (changeSequence.length <= 1) {
+        result.push(current);
+        i++;
+        continue;
+      }
+      const shouldConsolidate = this.shouldConsolidateChanges(
+        changeSequence
+      );
+      if (shouldConsolidate) {
+        const deletedWords = changeSequence.filter((c) => c.type === "delete").map((c) => c.value);
+        const insertedWords = changeSequence.filter((c) => c.type === "insert").map((c) => c.value);
+        if (deletedWords.length > 0) {
+          result.push({
+            type: "delete",
+            value: deletedWords.join(" "),
+            consolidated: true
+          });
+        }
+        if (insertedWords.length > 0) {
+          result.push({
+            type: "insert",
+            value: insertedWords.join(" "),
+            consolidated: true
+          });
+        }
+      } else {
+        changeSequence.forEach((change) => result.push(change));
+      }
+      i = j;
+    }
+    return result;
+  }
+  /**
+   * Determine if a sequence of changes should be consolidated
+   */
+  static shouldConsolidateChanges(changes) {
+    const hasDeletes = changes.some((c) => c.type === "delete");
+    const hasInserts = changes.some((c) => c.type === "insert");
+    return hasDeletes && hasInserts;
+  }
+  /**
+   * Check if two words are similar enough to be considered a replacement
+   */
+  static areWordsSimilar(word1, word2) {
+    if (word1 === word2) return true;
+    const maxLen = Math.max(word1.length, word2.length);
+    const minLen = Math.min(word1.length, word2.length);
+    if (maxLen > minLen * 2) {
+      return false;
+    }
+    const word1Clean = word1.replace(/[^\w]/g, "");
+    const word2Clean = word2.replace(/[^\w]/g, "");
+    if (word1Clean === word2Clean && word1 !== word2) {
+      return false;
+    }
+    const distance = this.levenshteinDistance(word1, word2);
+    const similarity = 1 - distance / maxLen;
+    return similarity > 0.7;
+  }
+};
+
+// src/utils/blocknote-word-diff-renderer.util.ts
+var BlockNoteWordDiffRendererUtil = class {
+  static {
+    __name(this, "BlockNoteWordDiffRendererUtil");
+  }
+  static renderWordDiffs(diffBlocks, onAcceptChange, onRejectChange, acceptedChanges, rejectedChanges) {
+    if (acceptedChanges || rejectedChanges) {
+      diffBlocks = this.updateWordDiffStates(diffBlocks, acceptedChanges, rejectedChanges);
+    }
+    return diffBlocks.map((block) => this.renderDiffBlock(block, onAcceptChange, onRejectChange));
+  }
+  static updateWordDiffStates(diffBlocks, acceptedChanges, rejectedChanges) {
+    return diffBlocks.map((block) => {
+      const updatedBlock = { ...block };
+      if (updatedBlock.diffId) {
+        updatedBlock.accepted = acceptedChanges?.has(updatedBlock.diffId) || false;
+        updatedBlock.rejected = rejectedChanges?.has(updatedBlock.diffId) || false;
+      }
+      if (updatedBlock.wordDiffs) {
+        updatedBlock.wordDiffs = updatedBlock.wordDiffs.map((wordDiff) => ({
+          ...wordDiff,
+          accepted: acceptedChanges?.has(wordDiff.diffId) || false,
+          rejected: rejectedChanges?.has(wordDiff.diffId) || false
+        }));
+      }
+      if (updatedBlock.children) {
+        updatedBlock.children = this.updateWordDiffStates(
+          updatedBlock.children,
+          acceptedChanges,
+          rejectedChanges
+        );
+      }
+      return updatedBlock;
+    });
+  }
+  static renderDiffBlock(block, onAcceptChange, onRejectChange) {
+    if (block.diffType === "modified" && block.wordDiffs) {
+      return this.renderWordLevelDiff(block, onAcceptChange, onRejectChange);
+    }
+    if (block.diffType === "added" || block.diffType === "removed") {
+      return this.renderBlockLevelDiff(block, onAcceptChange, onRejectChange);
+    }
+    const baseBlock = {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: this.getBlockProps(block),
+      content: Array.isArray(block.content) ? block.content : [],
+      children: block.children?.map(
+        (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+      )
+    };
+    return baseBlock;
+  }
+  static renderBlockLevelDiff(block, onAcceptChange, onRejectChange) {
+    if (!block.diffId) {
+      return {
+        id: block.id || crypto.randomUUID(),
+        type: block.type || "paragraph",
+        props: block.props || {},
+        content: Array.isArray(block.content) ? block.content : [],
+        children: block.children?.map(
+          (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+        )
+      };
+    }
+    const blockAccepted = block.accepted || false;
+    const blockRejected = block.rejected || false;
+    let content = Array.isArray(block.content) ? [...block.content] : [];
+    if (block.diffType === "added") {
+      if (blockRejected) {
+        return {
+          id: block.id || crypto.randomUUID(),
+          type: "paragraph",
+          props: {},
+          content: [],
+          children: []
+        };
+      } else if (!blockAccepted) {
+        content = content.map((item) => ({
+          ...item,
+          styles: { ...item.styles, bold: true }
+        }));
+        content.push({
+          type: "diffActions",
+          props: { diffIds: block.diffId }
+        });
+      }
+    } else if (block.diffType === "removed") {
+      if (blockAccepted) {
+        return {
+          id: block.id || crypto.randomUUID(),
+          type: "paragraph",
+          props: {},
+          content: [],
+          children: []
+        };
+      } else if (!blockRejected) {
+        content = content.map((item) => ({
+          ...item,
+          styles: { ...item.styles, strike: true }
+        }));
+        content.push({
+          type: "diffActions",
+          props: { diffIds: block.diffId }
+        });
+      }
+    }
+    const baseBlock = {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: this.getBlockProps(block),
+      content,
+      children: block.children?.map(
+        (child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)
+      )
+    };
+    return baseBlock;
+  }
+  static renderWordLevelDiff(block, onAcceptChange, onRejectChange) {
+    if (!block.wordDiffs) {
+      return {
+        id: block.id || crypto.randomUUID(),
+        type: block.type || "paragraph",
+        props: block.props || {},
+        content: Array.isArray(block.content) ? block.content : [],
+        children: []
+      };
+    }
+    const content = this.groupAndRenderWordDiffs(block.wordDiffs);
+    return {
+      id: block.id || crypto.randomUUID(),
+      type: block.type || "paragraph",
+      props: block.props || {},
+      content: Array.isArray(content) ? content : [],
+      children: block.children?.map((child) => this.renderDiffBlock(child, onAcceptChange, onRejectChange)) || []
+    };
+  }
+  static groupAndRenderWordDiffs(wordDiffs) {
+    const content = [];
+    for (let i = 0; i < wordDiffs.length; i++) {
+      const wordDiff = wordDiffs[i];
+      const isLastOfGroup = this.isLastDiffInGroup(wordDiffs, i);
+      const textContent = this.createTextContent(wordDiff, isLastOfGroup);
+      if (textContent) {
+        if (Array.isArray(textContent)) {
+          content.push(...textContent);
+        } else {
+          content.push(textContent);
+        }
+      }
+    }
+    const cleanedContent = this.cleanupSpaces(content);
+    return cleanedContent;
+  }
+  static cleanupSpaces(content) {
+    const filtered = content.filter((item) => item !== null && item !== void 0);
+    const cleaned = [];
+    for (let i = 0; i < filtered.length; i++) {
+      const current = filtered[i];
+      if (current.type === "text" && current.text === " ") {
+        const lastItem = cleaned[cleaned.length - 1];
+        if (i === 0 || i === filtered.length - 1 || lastItem && lastItem.type === "text" && lastItem.text === " " || lastItem && lastItem.type === "diffActions") {
+          continue;
+        }
+      }
+      if (current.type === "diffActions") {
+        const nextItem = i + 1 < filtered.length ? filtered[i + 1] : null;
+        cleaned.push(current);
+        if (nextItem && nextItem.type === "text" && nextItem.text !== " " && nextItem.type !== "diffActions") {
+          cleaned.push({
+            type: "text",
+            text: " ",
+            styles: {}
+          });
+        }
+        continue;
+      }
+      cleaned.push(current);
+    }
+    return cleaned;
+  }
+  static isLastDiffInGroup(wordDiffs, currentIndex) {
+    const currentDiff = wordDiffs[currentIndex];
+    if (currentDiff.type === "unchanged") {
+      return false;
+    }
+    for (let i = currentIndex + 1; i < wordDiffs.length; i++) {
+      const nextDiff = wordDiffs[i];
+      if (nextDiff.diffId === currentDiff.diffId && (nextDiff.type === "added" || nextDiff.type === "removed")) {
+        return false;
+      }
+      if (nextDiff.type !== "unchanged" && nextDiff.diffId !== currentDiff.diffId) {
+        break;
+      }
+    }
+    return true;
+  }
+  static createTextContent(wordDiff, isLastOfGroup) {
+    switch (wordDiff.type) {
+      case "added":
+        if (wordDiff.accepted) {
+          return {
+            type: "text",
+            text: wordDiff.text,
+            styles: {}
+          };
+        } else if (wordDiff.rejected) {
+          return null;
+        } else {
+          if (wordDiff.text.trim() === "") {
+            return {
+              type: "text",
+              text: wordDiff.text,
+              styles: { backgroundColor: "#dcfce7" }
+            };
+          } else {
+            const baseContent = {
+              type: "text",
+              text: wordDiff.text,
+              styles: { bold: true }
+            };
+            if (isLastOfGroup) {
+              return [
+                baseContent,
+                {
+                  type: "diffActions",
+                  props: { diffIds: wordDiff.diffId }
+                }
+              ];
+            } else {
+              return baseContent;
+            }
+          }
+        }
+      case "removed":
+        if (wordDiff.accepted) {
+          return null;
+        } else if (wordDiff.rejected) {
+          return {
+            type: "text",
+            text: wordDiff.text,
+            styles: {}
+          };
+        } else {
+          if (wordDiff.text.trim() === "") {
+            return {
+              type: "text",
+              text: wordDiff.text,
+              styles: { strike: true }
+            };
+          } else {
+            const baseContent = {
+              type: "text",
+              text: wordDiff.text,
+              styles: { strike: true }
+            };
+            if (isLastOfGroup) {
+              return [
+                baseContent,
+                {
+                  type: "diffActions",
+                  props: { diffIds: wordDiff.diffId }
+                }
+              ];
+            } else {
+              return baseContent;
+            }
+          }
+        }
+      case "unchanged":
+      default:
+        return {
+          type: "text",
+          text: wordDiff.text,
+          styles: {}
+        };
+    }
+  }
+  static getBlockProps(block) {
+    const baseProps = block.props || {};
+    return baseProps;
+  }
+  static generateChangeSummary(diffBlocks) {
+    let totalWords = 0;
+    let addedWords = 0;
+    let removedWords = 0;
+    let acceptedChanges = 0;
+    let rejectedChanges = 0;
+    let pendingChanges = 0;
+    const processBlock = /* @__PURE__ */ __name((block) => {
+      if (block.wordDiffs) {
+        block.wordDiffs.forEach((wordDiff) => {
+          totalWords++;
+          if (wordDiff.type === "added") {
+            addedWords++;
+          } else if (wordDiff.type === "removed") {
+            removedWords++;
+          }
+          if (wordDiff.accepted) {
+            acceptedChanges++;
+          } else if (wordDiff.rejected) {
+            rejectedChanges++;
+          } else if (wordDiff.type !== "unchanged") {
+            pendingChanges++;
+          }
+        });
+      }
+      if (block.children) {
+        block.children.forEach((child) => processBlock(child));
+      }
+    }, "processBlock");
+    diffBlocks.forEach(processBlock);
+    return {
+      totalWords,
+      addedWords,
+      removedWords,
+      acceptedChanges,
+      rejectedChanges,
+      pendingChanges
+    };
+  }
+};
+
+export {
+  cn,
+  composeRefs,
+  useComposedRefs,
+  useIsMobile,
+  formatDate,
+  exists,
+  TableOptions,
+  getTableOptions,
+  getTableComponents,
+  userObjectSchema,
+  entityObjectSchema,
+  BlockNoteDiffUtil,
+  BlockNoteWordDiffRendererUtil
+};
+//# sourceMappingURL=chunk-2LM6LCJW.mjs.map