web-doc 0.6.2 → 0.8.0

package/dist/edit/docx/schemas.js

@@ -0,0 +1,192 @@
+/*
+ * JSON Schemas of the DOCX operations, shared by the worker (engine
+ * validation), the main thread (shape checks) and clients
+ * (`session.schemas`). Only keywords the in-repo validator implements may
+ * appear here. The exported set lists the operations that have an engine
+ * handler.
+ */
+const HIGHLIGHTS = [
+    "yellow",
+    "green",
+    "cyan",
+    "magenta",
+    "blue",
+    "red",
+    "darkBlue",
+    "darkCyan",
+    "darkGreen",
+    "darkMagenta",
+    "darkRed",
+    "darkYellow",
+    "darkGray",
+    "lightGray",
+    "black",
+    "white",
+];
+const definitions = {
+    target: { type: "string", minLength: 1, maxLength: 200 },
+    textPosition: {
+        type: "object",
+        required: ["elementId", "offset"],
+        additionalProperties: false,
+        properties: {
+            elementId: { $ref: "#/$defs/target" },
+            offset: { type: "integer", minimum: 0 },
+        },
+    },
+    textRange: {
+        type: "object",
+        required: ["start", "end"],
+        additionalProperties: false,
+        properties: {
+            start: { $ref: "#/$defs/textPosition" },
+            end: { $ref: "#/$defs/textPosition" },
+        },
+    },
+    text: { type: "string", maxLength: 100_000 },
+    rgb: { type: "string", pattern: "^#[0-9A-Fa-f]{6}$" },
+    themeColor: {
+        type: "object",
+        required: ["theme"],
+        additionalProperties: false,
+        properties: {
+            theme: { type: "string", minLength: 1, maxLength: 20 },
+            mods: { type: "object" },
+        },
+    },
+    color: {
+        oneOf: [
+            { $ref: "#/$defs/rgb" },
+            { $ref: "#/$defs/themeColor" },
+            { const: "auto" },
+        ],
+    },
+    textStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            fontFamily: { type: "string", minLength: 1, maxLength: 100 },
+            fontSize: { type: "number", minimum: 1, maximum: 400 },
+            bold: { type: "boolean" },
+            italic: { type: "boolean" },
+            underline: { type: "boolean" },
+            color: { $ref: "#/$defs/color" },
+            highlight: { enum: [...HIGHLIGHTS, "none"] },
+        },
+    },
+    paragraphStyle: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            align: { enum: ["left", "center", "right", "justify"] },
+            spacing: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    before: { type: "number", minimum: 0, maximum: 1584 },
+                    after: { type: "number", minimum: 0, maximum: 1584 },
+                    line: { type: "number", minimum: 0.06, maximum: 132 },
+                },
+            },
+        },
+    },
+    tableRows: {
+        type: "array",
+        minItems: 1,
+        maxItems: 100,
+        items: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "string", maxLength: 10_000 },
+        },
+    },
+    index: { type: "integer", minimum: 0, maximum: 100_000 },
+    size: {
+        type: "object",
+        required: ["width", "height"],
+        additionalProperties: false,
+        properties: {
+            width: { type: "number", exclusiveMinimum: 0, maximum: 1584 },
+            height: { type: "number", exclusiveMinimum: 0, maximum: 1584 },
+        },
+    },
+};
+function operation(name, properties, required) {
+    return {
+        type: "object",
+        required: ["op", ...required],
+        additionalProperties: false,
+        properties: { op: { const: name }, ...properties },
+        $defs: definitions,
+    };
+}
+/** `before` or `after`: the element the operation places next to. */
+const placement = {
+    before: { $ref: "#/$defs/target" },
+    after: { $ref: "#/$defs/target" },
+};
+const all = {
+    replaceText: operation("replaceText", {
+        target: { $ref: "#/$defs/target" },
+        text: { $ref: "#/$defs/text" },
+        range: { $ref: "#/$defs/textRange" },
+    }, ["target", "text"]),
+    setTextStyle: operation("setTextStyle", {
+        target: { $ref: "#/$defs/target" },
+        range: { $ref: "#/$defs/textRange" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["target", "style"]),
+    setParagraphStyle: operation("setParagraphStyle", {
+        target: { $ref: "#/$defs/target" },
+        style: { $ref: "#/$defs/paragraphStyle" },
+    }, ["target", "style"]),
+    insertParagraph: operation("insertParagraph", {
+        ...placement,
+        text: { $ref: "#/$defs/text" },
+        style: { $ref: "#/$defs/textStyle" },
+    }, ["text"]),
+    deleteElement: operation("deleteElement", { target: { $ref: "#/$defs/target" } }, ["target"]),
+    moveElement: operation("moveElement", { target: { $ref: "#/$defs/target" }, ...placement }, ["target"]),
+    insertTable: operation("insertTable", {
+        ...placement,
+        rows: { $ref: "#/$defs/tableRows" },
+        columnWidths: {
+            type: "array",
+            minItems: 1,
+            maxItems: 20,
+            items: { type: "number", exclusiveMinimum: 0 },
+        },
+    }, ["rows"]),
+    setTableCell: operation("setTableCell", {
+        target: { $ref: "#/$defs/target" },
+        row: { $ref: "#/$defs/index" },
+        column: { $ref: "#/$defs/index" },
+        text: { $ref: "#/$defs/text" },
+    }, ["target", "row", "column", "text"]),
+    insertImage: operation("insertImage", {
+        ...placement,
+        data: { "x-binary": true, type: "string", contentEncoding: "base64" },
+        mimeType: { enum: ["image/png", "image/jpeg"] },
+        size: { $ref: "#/$defs/size" },
+    }, ["data", "mimeType", "size"]),
+};
+/** Operations with an engine handler; grows as the tasks land. */
+export const IMPLEMENTED_OPERATIONS = [
+    "replaceText",
+    "setTextStyle",
+    "setParagraphStyle",
+    "insertParagraph",
+    "deleteElement",
+    "moveElement",
+    "insertImage",
+    "insertTable",
+    "setTableCell",
+];
+export const docxOperationSchemas = Object.freeze({
+    format: "docx",
+    version: 1,
+    operations: Object.freeze(Object.fromEntries(IMPLEMENTED_OPERATIONS.map((name) => [name, all[name]]))),
+});
+/** Every schema, implemented or not, for the conformance test. */
+export const docxOperationSchemaDrafts = all;

package/dist/edit/docx/session.d.ts

@@ -0,0 +1,48 @@
+import type { DescribeOptions, DocumentDescription, EditCheckpoint, OutlineOptions, OutlineResult, TargetCandidate, TargetQuery, ToolCall, ToolCallOptions, ToolResult, ToolSet } from "../ai/types.js";
+import type { EditSessionAccess, EditSessionCore } from "../engine.js";
+import type { ApplyOptions, AssetOptions, EditFindOptions, EditOperation, EditReceipt, EditState, ElementQuery, HistoryOptions, OperationSchemaSet, PagePoint, PageRect, ReadItem, ReadOptions, ReadResult, SavedDocument, TextTarget } from "../types.js";
+import type { DocxDeleteElementOperation, DocxEditSession, DocxElement, DocxFields, DocxInsertImageOperation, DocxInsertParagraphOperation, DocxInsertTableOperation, DocxMoveElementOperation, DocxOperation, DocxReplaceTextOperation, DocxRevision, DocxSaveOptions, DocxSetParagraphStyleOperation, DocxSetTableCellOperation, DocxSetTextStyleOperation } from "./types.js";
+/** Per paragraph id (eight hex digits), the union of its runs per page. */
+type Placement = ReadonlyMap<string, ReadonlyMap<number, PageRect>>;
+export declare class DocxSession implements DocxEditSession {
+    #private;
+    readonly format: "docx";
+    constructor(core: EditSessionCore, access: EditSessionAccess);
+    get sessionId(): string;
+    get state(): EditState;
+    get schemas(): OperationSchemaSet;
+    apply(operations: readonly DocxOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    applyJson(operations: readonly EditOperation[], options?: ApplyOptions): Promise<EditReceipt>;
+    undo(options?: HistoryOptions): Promise<EditReceipt>;
+    redo(options?: HistoryOptions): Promise<EditReceipt>;
+    reset(options?: HistoryOptions): Promise<EditReceipt>;
+    save(options?: DocxSaveOptions): Promise<SavedDocument>;
+    markSaved(stateToken: string): void;
+    addAsset(data: Uint8Array, options?: AssetOptions): Promise<string>;
+    getElements(query?: ElementQuery, options?: ReadOptions): Promise<ReadResult<DocxElement>>;
+    getElement(id: string, options?: ReadOptions): Promise<ReadItem<DocxElement>>;
+    elementsAt(pageIndex: number, point: PagePoint, options?: ReadOptions): Promise<ReadResult<DocxElement>>;
+    findText(query: string, options?: EditFindOptions): Promise<ReadResult<TextTarget>>;
+    getOutline(options?: OutlineOptions): Promise<OutlineResult>;
+    describe(options?: DescribeOptions): Promise<ReadItem<DocumentDescription>>;
+    resolveTargets(query: TargetQuery, options?: ReadOptions): Promise<ReadResult<TargetCandidate>>;
+    createCheckpoint(label?: string): Promise<EditCheckpoint>;
+    listCheckpoints(): readonly EditCheckpoint[];
+    restoreCheckpoint(id: string, options?: HistoryOptions): Promise<EditReceipt>;
+    dropCheckpoint(id: string): void;
+    get tools(): ToolSet;
+    callTool(call: ToolCall, options?: ToolCallOptions): Promise<ToolResult>;
+    getRevisions(elementId: string, options?: ReadOptions): Promise<ReadResult<DocxRevision>>;
+    replaceText(fields: DocxFields<DocxReplaceTextOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTextStyle(fields: DocxFields<DocxSetTextStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setParagraphStyle(fields: DocxFields<DocxSetParagraphStyleOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertParagraph(fields: DocxFields<DocxInsertParagraphOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    deleteElement(fields: DocxFields<DocxDeleteElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    moveElement(fields: DocxFields<DocxMoveElementOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertTable(fields: DocxFields<DocxInsertTableOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    setTableCell(fields: DocxFields<DocxSetTableCellOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+    insertImage(fields: DocxFields<DocxInsertImageOperation>, options?: ApplyOptions): Promise<EditReceipt>;
+}
+/** Joins the engine's elements with the runs' placement. */
+export declare function placeElements(elements: readonly DocxElement[], placement: Placement): DocxElement[];
+export {};