@beyondwork/docx-react-component 1.0.27 → 1.0.29

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

@@ -1,565 +0,0 @@
-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";
-}