@carlonicora/nextjs-jsonapi 1.4.0 → 1.6.0

package/dist/chunk-JGFWIT2E.mjs

@@ -1,1131 +0,0 @@
-"use client";
-import {
-  Modules
-} from "./chunk-FMBQZAIP.mjs";
-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
-    };
-  }
-};
-
-// src/utils/icons.tsx
-import { jsx } from "react/jsx-runtime";
-var getIconByModule = /* @__PURE__ */ __name((params) => {
-  const IconComponent = getLucideIconByModule({ module: params.module });
-  if (!IconComponent) return null;
-  return /* @__PURE__ */ jsx(IconComponent, { className: cn(``, params.className) });
-}, "getIconByModule");
-var getIcon = /* @__PURE__ */ __name((params) => {
-  const IconComponent = getLucideIcon({ element: params.element });
-  if (!IconComponent) return null;
-  return /* @__PURE__ */ jsx(IconComponent, { className: cn(``, params.className) });
-}, "getIcon");
-var getIconByModuleName = /* @__PURE__ */ __name((params) => {
-  return getIconByModule({ module: Modules.findByModelName(params.name), className: params.className });
-}, "getIconByModuleName");
-var getLucideIcon = /* @__PURE__ */ __name((params) => {
-  if (params.element.type === "contents") {
-    const contentType = params.element.contentType;
-    if (!contentType) return null;
-    return getLucideIconByModule({ module: Modules.findByModelName(contentType) });
-  }
-  return getLucideIconByModule({ module: Modules.findByName(params.element.type) });
-}, "getLucideIcon");
-var getLucideIconByModule = /* @__PURE__ */ __name((params) => {
-  return params.module.icon ?? null;
-}, "getLucideIconByModule");
-var getLucideIconByModuleName = /* @__PURE__ */ __name((params) => {
-  return getLucideIconByModule({ module: Modules.findByModelName(params.name) });
-}, "getLucideIconByModuleName");
-
-export {
-  cn,
-  composeRefs,
-  useComposedRefs,
-  useIsMobile,
-  formatDate,
-  exists,
-  TableOptions,
-  getTableOptions,
-  getTableComponents,
-  userObjectSchema,
-  entityObjectSchema,
-  BlockNoteDiffUtil,
-  BlockNoteWordDiffRendererUtil,
-  getIconByModule,
-  getIcon,
-  getIconByModuleName,
-  getLucideIcon,
-  getLucideIconByModule,
-  getLucideIconByModuleName
-};
-//# sourceMappingURL=chunk-JGFWIT2E.mjs.map