@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/core/commands/list-commands.ts

@@ -0,0 +1,565 @@
+import type {
+  AbstractNumberingDefinition,
+  BlockNode,
+  CanonicalDocument as CanonicalDocumentEnvelope,
+  NumberingCatalog,
+  NumberingInstance,
+  ParagraphNode,
+} from "../../model/canonical-document.ts";
+
+export interface ListCommandContext {
+  timestamp: string;
+}
+
+export interface ListCommandResult {
+  document: CanonicalDocumentEnvelope;
+  affectedParagraphIndexes: number[];
+  createdNumberingInstanceId?: string;
+}
+
+export function toggleNumberedList(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  context: ListCommandContext,
+): ListCommandResult {
+  return toggleListKind(document, paragraphIndexes, "numbered", context);
+}
+
+export function toggleBulletedList(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  context: ListCommandContext,
+): ListCommandResult {
+  return toggleListKind(document, paragraphIndexes, "bulleted", context);
+}
+
+export function indentListItems(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  context: ListCommandContext,
+): ListCommandResult {
+  return adjustListLevels(document, paragraphIndexes, 1, context);
+}
+
+export function outdentListItems(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  context: ListCommandContext,
+): ListCommandResult {
+  return adjustListLevels(document, paragraphIndexes, -1, context);
+}
+
+/**
+ * Word-like Enter behavior on a list paragraph:
+ * - If the paragraph has content, split normally (caller handles the split).
+ *   Returns `action: "split"` so the caller can proceed with a standard paragraph split.
+ * - If the paragraph is empty AND at level > 0, outdent one level → `action: "outdented"`.
+ * - If the paragraph is empty AND at level 0, remove numbering → `action: "removed"`.
+ */
+export function splitListParagraph(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndex: number,
+  paragraphIsEmpty: boolean,
+  context: ListCommandContext,
+): ListCommandResult & { action: "split" | "outdented" | "removed" } {
+  if (!paragraphIsEmpty) {
+    return {
+      document,
+      affectedParagraphIndexes: [],
+      action: "split",
+    };
+  }
+
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const target = paragraphs[paragraphIndex];
+
+  if (!target?.numbering) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      action: "split",
+    };
+  }
+
+  if (target.numbering.level > 0) {
+    target.numbering = {
+      numberingInstanceId: target.numbering.numberingInstanceId,
+      level: clampLevel(target.numbering.level - 1),
+    };
+    return {
+      document: working,
+      affectedParagraphIndexes: [paragraphIndex],
+      action: "outdented",
+    };
+  }
+
+  delete target.numbering;
+  return {
+    document: working,
+    affectedParagraphIndexes: [paragraphIndex],
+    action: "removed",
+  };
+}
+
+/**
+ * Word-like Backspace at the start of a list paragraph:
+ * - If at level > 0, outdent one level.
+ * - If at level 0, remove numbering entirely.
+ * Returns the modified document and whether numbering was changed.
+ */
+export function backspaceAtListStart(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndex: number,
+  context: ListCommandContext,
+): ListCommandResult & { handled: boolean } {
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const target = paragraphs[paragraphIndex];
+
+  if (!target?.numbering) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+      handled: false,
+    };
+  }
+
+  if (target.numbering.level > 0) {
+    target.numbering = {
+      numberingInstanceId: target.numbering.numberingInstanceId,
+      level: clampLevel(target.numbering.level - 1),
+    };
+  } else {
+    delete target.numbering;
+  }
+
+  return {
+    document: working,
+    affectedParagraphIndexes: [paragraphIndex],
+    handled: true,
+  };
+}
+
+export function restartNumbering(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndex: number,
+  context: ListCommandContext,
+  startAt = 1,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const target = paragraphs[paragraphIndex];
+
+  if (!target?.numbering) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const catalog = ensureNumberingCatalog(working.numbering);
+  const existingInstance = catalog.instances[target.numbering.numberingInstanceId];
+  if (!existingInstance) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const numberingInstanceId = createNumberingInstanceId(catalog);
+  catalog.instances[numberingInstanceId] = {
+    numberingInstanceId,
+    abstractNumberingId: existingInstance.abstractNumberingId,
+    overrides: mergeOverride(existingInstance.overrides, {
+      level: target.numbering.level,
+      startAt,
+    }),
+  };
+
+  const affectedParagraphIndexes: number[] = [];
+  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+    const paragraph = paragraphs[index];
+    if (!paragraph?.numbering) {
+      break;
+    }
+    if (paragraph.numbering.numberingInstanceId !== existingInstance.numberingInstanceId) {
+      break;
+    }
+
+    paragraph.numbering = {
+      numberingInstanceId,
+      level: paragraph.numbering.level,
+    };
+    affectedParagraphIndexes.push(index);
+  }
+
+  working.numbering = catalog;
+
+  return {
+    document: working,
+    affectedParagraphIndexes,
+    createdNumberingInstanceId: numberingInstanceId,
+  };
+}
+
+export function continueNumbering(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndex: number,
+  context: ListCommandContext,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const target = paragraphs[paragraphIndex];
+
+  if (!target?.numbering) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const catalog = ensureNumberingCatalog(working.numbering);
+  const currentInstanceId = target.numbering.numberingInstanceId;
+  const currentKind = getListKind(catalog, currentInstanceId);
+  if (!currentKind) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const compatibleInstanceId = findPreviousCompatibleInstance(
+    paragraphs,
+    catalog,
+    paragraphIndex,
+    currentKind,
+  );
+  if (!compatibleInstanceId || compatibleInstanceId === currentInstanceId) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const affectedParagraphIndexes: number[] = [];
+  for (let index = paragraphIndex; index < paragraphs.length; index += 1) {
+    const paragraph = paragraphs[index];
+    if (!paragraph?.numbering) {
+      break;
+    }
+    if (paragraph.numbering.numberingInstanceId !== currentInstanceId) {
+      break;
+    }
+    paragraph.numbering = {
+      numberingInstanceId: compatibleInstanceId,
+      level: paragraph.numbering.level,
+    };
+    affectedParagraphIndexes.push(index);
+  }
+
+  working.numbering = catalog;
+
+  return {
+    document: working,
+    affectedParagraphIndexes,
+    createdNumberingInstanceId: compatibleInstanceId,
+  };
+}
+
+function toggleListKind(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  kind: "numbered" | "bulleted",
+  context: ListCommandContext,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const normalizedIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+
+  if (normalizedIndexes.length === 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const catalog = ensureNumberingCatalog(working.numbering);
+  const allAlreadyKind = normalizedIndexes.every((index) => {
+    const paragraph = paragraphs[index] as ParagraphNode;
+    return paragraph.numbering
+      ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind
+      : false;
+  });
+
+  if (allAlreadyKind) {
+    for (const index of normalizedIndexes) {
+      delete (paragraphs[index] as ParagraphNode).numbering;
+    }
+    working.numbering = catalog;
+    return {
+      document: working,
+      affectedParagraphIndexes: normalizedIndexes,
+    };
+  }
+
+  const numberingInstanceId =
+    findAdjacentCompatibleInstance(paragraphs, catalog, normalizedIndexes[0]!, kind) ??
+    ensureDefaultInstance(catalog, kind);
+
+  for (const index of normalizedIndexes) {
+    const paragraph = paragraphs[index] as ParagraphNode;
+    paragraph.numbering = {
+      numberingInstanceId,
+      level: clampLevel(paragraph.numbering?.level ?? 0),
+    };
+  }
+
+  working.numbering = catalog;
+
+  return {
+    document: working,
+    affectedParagraphIndexes: normalizedIndexes,
+    createdNumberingInstanceId: numberingInstanceId,
+  };
+}
+
+function adjustListLevels(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  delta: -1 | 1,
+  context: ListCommandContext,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const paragraphs = captureEditableParagraphs(working);
+  const affectedParagraphIndexes = normalizeParagraphIndexes(paragraphs, paragraphIndexes).filter(
+    (index) => Boolean(paragraphs[index]?.numbering),
+  );
+
+  for (const index of affectedParagraphIndexes) {
+    const paragraph = paragraphs[index] as ParagraphNode;
+    if (!paragraph.numbering) {
+      continue;
+    }
+
+    paragraph.numbering = {
+      numberingInstanceId: paragraph.numbering.numberingInstanceId,
+      level: clampLevel(paragraph.numbering.level + delta),
+    };
+  }
+
+  return {
+    document: working,
+    affectedParagraphIndexes,
+  };
+}
+
+function ensureDefaultInstance(
+  catalog: NumberingCatalog,
+  kind: "numbered" | "bulleted",
+): string {
+  const existing = Object.values(catalog.instances).find(
+    (instance) => getListKind(catalog, instance.numberingInstanceId) === kind,
+  );
+  if (existing) {
+    return existing.numberingInstanceId;
+  }
+
+  const abstractNumberingId = createAbstractNumberingId(catalog);
+  catalog.abstractDefinitions[abstractNumberingId] =
+    kind === "bulleted" ? createDefaultBulletedDefinition(abstractNumberingId) : createDefaultNumberedDefinition(abstractNumberingId);
+
+  const numberingInstanceId = createNumberingInstanceId(catalog);
+  catalog.instances[numberingInstanceId] = {
+    numberingInstanceId,
+    abstractNumberingId,
+    overrides: [],
+  };
+
+  return numberingInstanceId;
+}
+
+function findAdjacentCompatibleInstance(
+  paragraphs: readonly ParagraphNode[],
+  catalog: NumberingCatalog,
+  fromIndex: number,
+  kind: "numbered" | "bulleted",
+): string | undefined {
+  const previous = paragraphs[fromIndex - 1];
+  if (previous?.numbering) {
+    const previousKind = getListKind(catalog, previous.numbering.numberingInstanceId);
+    if (previousKind === kind) {
+      return previous.numbering.numberingInstanceId;
+    }
+  }
+
+  return undefined;
+}
+
+function findPreviousCompatibleInstance(
+  paragraphs: readonly ParagraphNode[],
+  catalog: NumberingCatalog,
+  fromIndex: number,
+  kind: "numbered" | "bulleted",
+): string | undefined {
+  for (let index = fromIndex - 1; index >= 0; index -= 1) {
+    const paragraph = paragraphs[index];
+    if (!paragraph?.numbering) {
+      continue;
+    }
+    if (getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind) {
+      return paragraph.numbering.numberingInstanceId;
+    }
+  }
+  return undefined;
+}
+
+function getListKind(
+  catalog: NumberingCatalog,
+  numberingInstanceId: string,
+): "numbered" | "bulleted" | undefined {
+  const instance = catalog.instances[numberingInstanceId];
+  const definition = instance
+    ? catalog.abstractDefinitions[instance.abstractNumberingId]
+    : undefined;
+  const levelZero = definition?.levels.find((level) => level.level === 0);
+  if (!levelZero) {
+    return undefined;
+  }
+
+  return levelZero.format === "bullet" ? "bulleted" : "numbered";
+}
+
+function mergeOverride(
+  overrides: NumberingInstance["overrides"],
+  nextOverride: NumberingInstance["overrides"][number],
+): NumberingInstance["overrides"] {
+  const filtered = overrides.filter((override) => override.level !== nextOverride.level);
+  filtered.push(nextOverride);
+  return filtered.sort((left, right) => left.level - right.level);
+}
+
+function createDefaultNumberedDefinition(abstractNumberingId: string): AbstractNumberingDefinition {
+  return {
+    abstractNumberingId,
+    levels: [
+      { level: 0, format: "decimal", text: "%1." },
+      { level: 1, format: "decimal", text: "%1.%2." },
+      { level: 2, format: "lowerLetter", text: "(%3)" },
+      { level: 3, format: "lowerRoman", text: "(%4)" },
+      { level: 4, format: "decimal", text: "%5." },
+      { level: 5, format: "lowerLetter", text: "(%6)" },
+      { level: 6, format: "lowerRoman", text: "(%7)" },
+      { level: 7, format: "decimal", text: "%8." },
+      { level: 8, format: "lowerLetter", text: "(%9)" },
+    ],
+  };
+}
+
+function createDefaultBulletedDefinition(abstractNumberingId: string): AbstractNumberingDefinition {
+  return {
+    abstractNumberingId,
+    levels: [
+      { level: 0, format: "bullet", text: "•" },
+      { level: 1, format: "bullet", text: "o" },
+      { level: 2, format: "bullet", text: "■" },
+      { level: 3, format: "bullet", text: "•" },
+      { level: 4, format: "bullet", text: "o" },
+      { level: 5, format: "bullet", text: "■" },
+      { level: 6, format: "bullet", text: "•" },
+      { level: 7, format: "bullet", text: "o" },
+      { level: 8, format: "bullet", text: "■" },
+    ],
+  };
+}
+
+function createAbstractNumberingId(catalog: NumberingCatalog): string {
+  let index = 1;
+  while (catalog.abstractDefinitions[`abstract-num:generated-${index}`]) {
+    index += 1;
+  }
+
+  return `abstract-num:generated-${index}`;
+}
+
+function createNumberingInstanceId(catalog: NumberingCatalog): string {
+  let index = 1;
+  while (catalog.instances[`num:generated-${index}`]) {
+    index += 1;
+  }
+
+  return `num:generated-${index}`;
+}
+
+function ensureNumberingCatalog(value: NumberingCatalog): NumberingCatalog {
+  return structuredClone(value);
+}
+
+function cloneEnvelope(
+  document: CanonicalDocumentEnvelope,
+  timestamp: string,
+): CanonicalDocumentEnvelope {
+  return {
+    ...structuredClone(document),
+    updatedAt: timestamp,
+  };
+}
+
+function captureEditableParagraphs(document: CanonicalDocumentEnvelope): ParagraphNode[] {
+  if (isDocumentRoot(document.content)) {
+    const paragraphs: ParagraphNode[] = [];
+    collectEditableParagraphs(document.content.children as BlockNode[], paragraphs);
+    return paragraphs;
+  }
+
+  const fallback = {
+    type: "doc" as const,
+    children: [{ type: "paragraph" as const, children: [] }],
+  };
+  document.content = fallback;
+  return fallback.children as ParagraphNode[];
+}
+
+function collectEditableParagraphs(
+  blocks: readonly BlockNode[],
+  output: ParagraphNode[],
+): void {
+  for (const block of blocks) {
+    switch (block.type) {
+      case "paragraph":
+        output.push(block);
+        break;
+      case "table":
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            collectEditableParagraphs(cell.children, output);
+          }
+        }
+        break;
+      case "sdt":
+        collectEditableParagraphs(block.children, output);
+        break;
+      case "custom_xml":
+        break;
+      default:
+        break;
+    }
+  }
+}
+
+function normalizeParagraphIndexes(
+  paragraphs: readonly ParagraphNode[],
+  paragraphIndexes: readonly number[],
+): number[] {
+  return [...new Set(paragraphIndexes)]
+    .filter((index) => Number.isInteger(index) && index >= 0 && index < paragraphs.length)
+    .sort((left, right) => left - right);
+}
+
+function clampLevel(level: number): number {
+  return Math.max(0, Math.min(8, level));
+}
+
+function isDocumentRoot(value: unknown): value is { type: "doc"; children: unknown[] } {
+  return Boolean(value) && typeof value === "object" && (value as { type?: string }).type === "doc";
+}