@beyondwork/docx-react-component 1.0.1 → 1.0.2

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

@@ -0,0 +1,370 @@
+import type {
+  AbstractNumberingDefinition,
+  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;
+}
+
+type OpaqueBlockLike = { type: "opaque_block"; [key: string]: unknown };
+type BlockLike = ParagraphNode | OpaqueBlockLike;
+
+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);
+}
+
+export function restartNumbering(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndex: number,
+  context: ListCommandContext,
+  startAt = 1,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const blocks = captureBlocks(working);
+  const target = blocks[paragraphIndex];
+
+  if (!isParagraphNode(target) || !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 < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (!isParagraphNode(block)) {
+      break;
+    }
+    if (block.numbering?.numberingInstanceId !== existingInstance.numberingInstanceId) {
+      break;
+    }
+
+    block.numbering = {
+      numberingInstanceId,
+      level: block.numbering.level,
+    };
+    affectedParagraphIndexes.push(index);
+  }
+
+  working.numbering = catalog;
+
+  return {
+    document: working,
+    affectedParagraphIndexes,
+    createdNumberingInstanceId: numberingInstanceId,
+  };
+}
+
+function toggleListKind(
+  document: CanonicalDocumentEnvelope,
+  paragraphIndexes: readonly number[],
+  kind: "numbered" | "bulleted",
+  context: ListCommandContext,
+): ListCommandResult {
+  const working = cloneEnvelope(document, context.timestamp);
+  const blocks = captureBlocks(working);
+  const normalizedIndexes = normalizeParagraphIndexes(blocks, paragraphIndexes);
+
+  if (normalizedIndexes.length === 0) {
+    return {
+      document: working,
+      affectedParagraphIndexes: [],
+    };
+  }
+
+  const catalog = ensureNumberingCatalog(working.numbering);
+  const allAlreadyKind = normalizedIndexes.every((index) => {
+    const paragraph = blocks[index] as ParagraphNode;
+    return paragraph.numbering
+      ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind
+      : false;
+  });
+
+  if (allAlreadyKind) {
+    for (const index of normalizedIndexes) {
+      delete (blocks[index] as ParagraphNode).numbering;
+    }
+    working.numbering = catalog;
+    return {
+      document: working,
+      affectedParagraphIndexes: normalizedIndexes,
+    };
+  }
+
+  const numberingInstanceId =
+    findAdjacentCompatibleInstance(blocks, catalog, normalizedIndexes[0]!, kind) ??
+    ensureDefaultInstance(catalog, kind);
+
+  for (const index of normalizedIndexes) {
+    const paragraph = blocks[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 blocks = captureBlocks(working);
+  const affectedParagraphIndexes = normalizeParagraphIndexes(blocks, paragraphIndexes).filter(
+    (index) => isParagraphNode(blocks[index]) && Boolean((blocks[index] as ParagraphNode).numbering),
+  );
+
+  for (const index of affectedParagraphIndexes) {
+    const paragraph = blocks[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(
+  blocks: BlockLike[],
+  catalog: NumberingCatalog,
+  fromIndex: number,
+  kind: "numbered" | "bulleted",
+): string | undefined {
+  const previous = blocks[fromIndex - 1];
+  if (isParagraphNode(previous) && previous.numbering) {
+    const previousKind = getListKind(catalog, previous.numbering.numberingInstanceId);
+    if (previousKind === kind) {
+      return previous.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 captureBlocks(document: CanonicalDocumentEnvelope): BlockLike[] {
+  if (isDocumentRoot(document.content)) {
+    return document.content.children as BlockLike[];
+  }
+
+  const fallback = {
+    type: "doc" as const,
+    children: [{ type: "paragraph" as const, children: [] }],
+  };
+  document.content = fallback;
+  return fallback.children as BlockLike[];
+}
+
+function normalizeParagraphIndexes(
+  blocks: BlockLike[],
+  paragraphIndexes: readonly number[],
+): number[] {
+  return [...new Set(paragraphIndexes)]
+    .filter((index) => Number.isInteger(index) && index >= 0 && index < blocks.length)
+    .filter((index) => isParagraphNode(blocks[index]))
+    .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";
+}
+
+function isParagraphNode(value: unknown): value is ParagraphNode {
+  return Boolean(value) && typeof value === "object" && (value as { type?: string }).type === "paragraph";
+}
+

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

@@ -0,0 +1,108 @@
+export interface ReviewCommandOrigin {
+  source:
+    | "keyboard"
+    | "toolbar"
+    | "context_menu"
+    | "comment_panel"
+    | "review_panel"
+    | "api"
+    | "runtime";
+  timestamp: string;
+}
+
+export type ReviewCommand =
+  | {
+      type: "review.accept-revision";
+      revisionId: string;
+      origin?: ReviewCommandOrigin;
+    }
+  | {
+      type: "review.reject-revision";
+      revisionId: string;
+      origin?: ReviewCommandOrigin;
+    }
+  | {
+      type: "review.accept-all-revisions";
+      origin?: ReviewCommandOrigin;
+    }
+  | {
+      type: "review.reject-all-revisions";
+      origin?: ReviewCommandOrigin;
+    };
+
+export type SingleRevisionReviewCommand = Extract<
+  ReviewCommand,
+  { revisionId: string }
+>;
+
+export type BatchRevisionReviewCommand = Exclude<
+  ReviewCommand,
+  SingleRevisionReviewCommand
+>;
+
+export type ReviewCommandIntent = "accept" | "reject";
+
+export function isSingleRevisionReviewCommand(
+  command: ReviewCommand,
+): command is SingleRevisionReviewCommand {
+  return "revisionId" in command;
+}
+
+export function isBatchRevisionReviewCommand(
+  command: ReviewCommand,
+): command is BatchRevisionReviewCommand {
+  return !isSingleRevisionReviewCommand(command);
+}
+
+export function getReviewCommandIntent(
+  command: ReviewCommand,
+): ReviewCommandIntent {
+  switch (command.type) {
+    case "review.accept-revision":
+    case "review.accept-all-revisions":
+      return "accept";
+    case "review.reject-revision":
+    case "review.reject-all-revisions":
+      return "reject";
+  }
+}
+
+export function createAcceptRevisionCommand(
+  revisionId: string,
+  origin?: ReviewCommandOrigin,
+): SingleRevisionReviewCommand {
+  return {
+    type: "review.accept-revision",
+    revisionId,
+    ...(origin ? { origin } : {}),
+  };
+}
+
+export function createRejectRevisionCommand(
+  revisionId: string,
+  origin?: ReviewCommandOrigin,
+): SingleRevisionReviewCommand {
+  return {
+    type: "review.reject-revision",
+    revisionId,
+    ...(origin ? { origin } : {}),
+  };
+}
+
+export function createAcceptAllRevisionsCommand(
+  origin?: ReviewCommandOrigin,
+): BatchRevisionReviewCommand {
+  return {
+    type: "review.accept-all-revisions",
+    ...(origin ? { origin } : {}),
+  };
+}
+
+export function createRejectAllRevisionsCommand(
+  origin?: ReviewCommandOrigin,
+): BatchRevisionReviewCommand {
+  return {
+    type: "review.reject-all-revisions",
+    ...(origin ? { origin } : {}),
+  };
+}

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

@@ -0,0 +1,119 @@
+import type { CanonicalDocumentEnvelope, SelectionSnapshot } from "../state/editor-state.ts";
+import {
+  applyTextTransaction,
+  type TextTransactionResult,
+} from "../state/text-transaction.ts";
+
+export interface TextCommandContext {
+  timestamp: string;
+}
+
+export function insertText(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  text: string,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [
+        {
+          type: "text",
+          text,
+        },
+      ],
+    },
+    context,
+  );
+}
+
+export function deleteSelectionOrBackward(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    selection.isCollapsed
+      ? {
+          type: "delete_backward",
+        }
+      : {
+          type: "replace",
+          insertion: [],
+        },
+    context,
+  );
+}
+
+export function deleteSelectionOrForward(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    selection.isCollapsed
+      ? {
+          type: "delete_forward",
+        }
+      : {
+          type: "replace",
+          insertion: [],
+        },
+    context,
+  );
+}
+
+export function insertTab(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "tab" }],
+    },
+    context,
+  );
+}
+
+export function insertHardBreak(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "hard_break" }],
+    },
+    context,
+  );
+}
+
+export function splitParagraph(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): TextTransactionResult {
+  return applyTextTransaction(
+    document,
+    selection,
+    {
+      type: "replace",
+      insertion: [{ type: "paragraph_break" }],
+    },
+    context,
+  );
+}

package/src/core/schema/README.md

@@ -0,0 +1,3 @@
+# Core Schema
+
+Canonical node, mark, and attribute definitions belong here.