Text Splitting Function Code

OK, let's break down the task: the function splitText(node) takes a node object with text and formatting as ranges, splitting the text into chunks of at most maxLength (32).

Ensuring optimal splits

I'm working on ensuring each chunk's total length, including formatting overhead, does not exceed the specified maximum length. Adjusting formatting objects within chunks to maintain this limit is crucial.

Enhancing code readability

I'm thinking about optimizing the code by precomputing text split positions and avoiding nested loops to streamline the solution.

Ensuring content fit

First, I check if the text fits within the maxLength. If not, I divide it into chunks, carefully adjusting the endIndex to avoid splitting words. This approach ensures the content maintains readability and clarity.

Creating a function

I’m piecing together a function to evaluate chunk overlap based on formatting markers. This involves pre-scanning formatting objects to simplify the overhead calculation.

Breaking down the content

I’m piecing together methods to split the text into chunks, ensuring each chunk fits the maxLength limit by calculating cumulative formatting overhead.

Mapping the process

OK, let me see. I’m thinking about mapping out an array of events to track active formatting objects in the text, ensuring each chunk's overhead is accounted for.

Refining text splitting

I’m working on refining a JavaScript function to split text nodes into chunks, maintaining formatting objects. The function calculates overhead, manages formatting objects, and ensures chunks fit within a specified maximum length.

Mapping out options

I'm considering expanding the text with formatting markers, splitting into chunks, and managing overhead characters. This might simplify the code and make it more efficient.

Weighing options

I'm considering the benefits of a precomputed array to track cumulative formatting object overlaps, weighing the simplicity and efficiency of this approach against more detailed methods.

Streamlining text

Refining the function to split text into chunks while managing formatting objects and ensuring a maximum length of 32. Adjusting endIndex to fit within constraints and reconstructing formatting objects for each chunk.

Evaluating options

Examining various methods for splitting text into chunks of maximum length and addressing per-chunk overheads. Considering recursive and simplified code, as well as precomputing overheads.

Evaluating overhead options

I’m considering calculating the total overhead for a chunk by examining the number of unique formatting objects that overlap it, noting that each overlap introduces an overhead of 2 characters.

Mapping the process

I’m outlining a method to calculate formatting overhead for each chunk in the text. This involves computing active formatting objects, adjusting chunk boundaries based on maximum allowed length, and minimizing total overhead while ensuring the chunk length stays within the limit.

Ensuring text division

I’m dividing text nodes into chunks, considering formatting and adjusting formatting objects for balanced formatting.

Enhancing efficiency

I'm thinking about refining the code by using an index in formattingObjects to streamline repetitive filtering. This method could improve performance and minimize redundant calculations.

Setting up variables

I’m thinking through initializing variables, iterating through text, and adjusting endIndex to ensure chunkOverhead remains within limits. Helper functions might streamline this logic.

Splitting text efficiently

I’m breaking down the text into chunks of up to 32 characters, ensuring overlap and formatting precision. Adjusting indices to avoid cutting through spaces or newlines.

function splitText(node) {
  const maxLength = 32;
  const text = node.value;
  const formattingObjects = node.formatting?.bold || [];
  const result = [];

  // Check if the entire text fits within maxLength including formatting overhead
  const totalOverhead = formattingObjects.length * 2;
  if (text.length + totalOverhead <= maxLength) {
    result.push({ ...node });
    return result;
  }

  // Sort formatting objects by their begin positions
  formattingObjects.sort((a, b) => a.begin - b.begin);

  let startIndex = 0;

  while (startIndex < text.length) {
    let endIndex = Math.min(startIndex + maxLength, text.length);

    // Try to adjust endIndex to previous newline or space
    const newlineIndex = text.lastIndexOf('\n', endIndex - 1);
    const spaceIndex = text.lastIndexOf(' ', endIndex - 1);
    const adjustedIndex = Math.max(newlineIndex, spaceIndex);
    if (adjustedIndex >= startIndex) {
      endIndex = adjustedIndex + 1;
    }

    // Find overlapping formatting objects
    const overlappingFormats = formattingObjects.filter(
      (fmt) => fmt.end > startIndex && fmt.begin < endIndex
    );
    const overhead = overlappingFormats.length * 2;
    let totalLength = (endIndex - startIndex) + overhead;

    // Adjust endIndex if totalLength exceeds maxLength
    while (totalLength > maxLength && endIndex > startIndex) {
      endIndex--;
      const newOverlappingFormats = formattingObjects.filter(
        (fmt) => fmt.end > startIndex && fmt.begin < endIndex
      );
      const newOverhead = newOverlappingFormats.length * 2;
      totalLength = (endIndex - startIndex) + newOverhead;
    }

    // Ensure at least one character is included
    if (endIndex <= startIndex) {
      endIndex = startIndex + 1;
    }

    // Extract substring and adjust formatting objects
    const substring = text.substring(startIndex, endIndex).trim();
    const newNode = { ...node, value: substring };
    newNode.formatting = {
      bold: overlappingFormats.map((fmt) => ({
        begin: Math.max(fmt.begin, startIndex) - startIndex,
        end: Math.min(fmt.end, endIndex) - startIndex,
      })),
    };

    result.push(newNode);
    startIndex = endIndex;
  }

  return result;
}

const node = {
  id: 1,
  value:
    'Очень длин\nный текст, который нужно разделить на части не длиннее 32 символов.',
  formatting: {
    bold: [{ begin: 6, end: 14 }],
  },
};
const splitNodes = splitText(node);
console.log(JSON.stringify(splitNodes, null, 3));

[
   {
      "id": 1,
      "value": "Очень длин",
      "formatting": {
         "bold": [
            {
               "begin": 6,
               "end": 8
            }
         ]
      }
   },
   {
      "id": 1,
      "value": "ный текст, который нужно",
      "formatting": {
         "bold": [
            {
               "begin": 0,
               "end": 6
            }
         ]
      }
   },
   {
      "id": 1,
      "value": "разделить на части не длиннее",
      "formatting": {
         "bold": []
      }
   },
   {
      "id": 1,
      "value": "32 символов.",
      "formatting": {
         "bold": []
      }
   }
]

Text Splitting Function Code

Question

Thought

Answer

Share this Q&A