@kerebron/extension-odt 0.4.28 → 0.4.30

package/src/OdtParser.ts

@@ -0,0 +1,350 @@
+import { Mark, Node, Schema } from 'prosemirror-model';
+import {
+  getBasicNodesHandlers,
+  getInlineNodesHandlers,
+} from './node_handlers/basic_node_handlers.js';
+import { getListNodesHandlers } from './node_handlers/list_node_handlers.js';
+import { getTableNodesHandlers } from './node_handlers/table_node_handlers.js';
+import { ListTracker } from './lists.js';
+import { type UrlRewriter } from '@kerebron/editor';
+
+const COURIER_FONTS = ['Courier New', 'Courier', 'Roboto Mono'];
+
+export interface OdtElement {
+  $value: 'TODO';
+}
+
+export type NodeHandler = (ctx: OdtStashContext, value: any) => void;
+
+interface ListStyle {
+  '@name': string;
+}
+
+interface Style {
+  '@name': string;
+  '@parent-style-name'?: string;
+  styles: string[];
+}
+
+interface StylesTree {
+  styles: {
+    'list-style': Array<ListStyle>;
+    'style': Array<Style>;
+  };
+}
+
+interface AutomaticStyles {
+  'style': Array<Style>;
+}
+
+export function resolveStyle(
+  stylesTree: StylesTree,
+  automaticStyles: AutomaticStyles,
+  name: string,
+): Style {
+  let style: Style;
+
+  if (!style) {
+    style = stylesTree.styles['list-style'].find((item) =>
+      item['@name'] === name
+    );
+  }
+  if (!style) {
+    style = stylesTree.styles['style'].find((item) => item['@name'] === name);
+  }
+  if (!style) {
+    style = automaticStyles.style.find((item) => item['@name'] === name);
+  }
+
+  if (!style) {
+    style = {
+      '@name': name,
+    };
+  }
+
+  style['styles'] = [name];
+
+  if (style['@parent-style-name']) {
+    const parentStyle = resolveStyle(
+      stylesTree,
+      automaticStyles,
+      style['@parent-style-name'],
+    );
+    if (parentStyle) {
+      const styles = [...style['styles'], ...parentStyle['styles']];
+      for (const key in style) {
+        if (typeof style[key] === 'undefined') {
+          delete style[key];
+        }
+      }
+      style = {
+        ...parentStyle,
+        ...style,
+        styles,
+      };
+    }
+  }
+  return style;
+}
+
+export interface TaggedEnum {
+  tag: string;
+  value: any;
+}
+
+export function tagEnum(item: any) {
+  if ('string' === typeof item) {
+    return {
+      tag: item, // '$text',
+      value: item,
+    };
+  }
+  if ('object' === typeof item) {
+    const entries = Object.entries(item);
+    if (entries.length === 1) {
+      return {
+        tag: entries[0][0],
+        value: entries[0][1],
+      };
+    }
+  }
+
+  throw new Error('Incorrect enum: ' + JSON.stringify(item));
+}
+
+export function iterateChildren(
+  nodes: unknown[],
+  callback: (item: TaggedEnum) => void,
+) {
+  for (const child of nodes) {
+    if ('Unknown' === child) {
+      continue;
+    }
+
+    const item = tagEnum(child);
+
+    callback(item);
+  }
+}
+
+export function iterateEnum($value: unknown[]): Array<TaggedEnum> {
+  if (!$value) {
+    return [];
+  }
+  return $value.map(tagEnum);
+}
+
+export interface OdtParserConfig {
+}
+
+export interface OdtContext {
+  handlers: Record<string, NodeHandler>;
+  content: Node[];
+  marks: Mark[];
+  meta: Record<string, any>;
+}
+
+export class OdtStashContext {
+  private ctxStash: Array<OdtContext> = [];
+  private currentCtx: OdtContext;
+  public listTracker = new ListTracker();
+  constructor(
+    readonly schema: Schema,
+    handlers: Record<string, NodeHandler>,
+    readonly stylesTree: StylesTree,
+    readonly automaticStyles: AutomaticStyles,
+  ) {
+    this.currentCtx = {
+      handlers,
+      content: [],
+      marks: [],
+      meta: {},
+    };
+    this.stash();
+  }
+
+  public stash(): number {
+    this.ctxStash.push(this.currentCtx);
+    const funcs = {};
+    const handlers = { ...this.currentCtx.handlers };
+    const content = this.currentCtx.content;
+    const marks = this.currentCtx.marks;
+    this.currentCtx = {
+      ...structuredClone({
+        ...this.currentCtx,
+        content: undefined,
+        marks: undefined,
+        handlers: undefined,
+      }),
+      ...funcs,
+      content,
+      marks,
+      handlers,
+    };
+
+    return this.ctxStash.length - 1;
+  }
+
+  public unstash() {
+    const ctx = this.ctxStash.pop();
+    if (!ctx) {
+      throw new Error('Unstash failed');
+    }
+    this.currentCtx = ctx;
+  }
+
+  public openNode() {
+    this.stash();
+    this.current.content = [];
+  }
+
+  public closeNode(type: string, attrs = {}, marks = Mark.none) {
+    const node = this.createNode(type, attrs, marks);
+    this.unstash();
+    if (node) {
+      this.current.content.push(node);
+    }
+    return node;
+  }
+
+  private createNode(type: string, attrs = {}, marks = Mark.none) {
+    const nodeType = this.schema.nodes[type];
+    if (!nodeType) {
+      throw new Error('Invalid node type: ' + type);
+    }
+    const node = nodeType.createAndFill(attrs, this.current.content, marks);
+    if (!node) {
+      throw new Error('Error creating node: ' + type);
+    }
+    return node;
+  }
+
+  createText(text: string) {
+    if (!text) return;
+    return this.schema.text(text, this.current.marks);
+  }
+
+  public styleToMarks(style: Style): Mark[] {
+    const marks: Mark[] = [];
+    const textProperties = style && style['text-properties'] || {};
+
+    if (COURIER_FONTS.indexOf(textProperties['@font-name'] || '') > -1) {
+      const markType = this.schema.mark('code');
+      marks.push(markType);
+    }
+
+    if (textProperties['@font-style'] === 'italic') {
+      const markType = this.schema.mark('em');
+      marks.push(markType);
+    }
+    if (textProperties['@font-weight'] === 'bold') {
+      const markType = this.schema.mark('strong');
+      marks.push(markType);
+    }
+
+    return marks;
+  }
+
+  public handle(nodeType: string, value: any) {
+    if (!this.current.handlers[nodeType]) {
+      throw new Error('No handler for node: ' + nodeType);
+    }
+    if ('function' !== typeof this.current.handlers[nodeType]) {
+      throw new Error('Invalid handler for node: ' + nodeType);
+    }
+
+    this.current.handlers[nodeType](this, value);
+  }
+
+  public getElementStyle(element: any): Style {
+    const style = ('object' === typeof element && element['@style-name'])
+      ? resolveStyle(
+        this.stylesTree,
+        this.automaticStyles,
+        element['@style-name'],
+      )
+      : {};
+
+    return style;
+  }
+
+  get current() {
+    return this.currentCtx;
+  }
+}
+
+export class OdtParser {
+  constructor(
+    private readonly schema: Schema,
+    private readonly config: OdtParserConfig = {},
+  ) {}
+
+  public filesMap?: Record<string, Uint8Array<ArrayBufferLike>>;
+
+  parse(files: any) {
+    const contentTree = files.contentTree;
+    const stylesTree = files.stylesTree;
+
+    const handlers: Record<string, NodeHandler> = {
+      ...getInlineNodesHandlers(),
+      ...getBasicNodesHandlers(),
+      ...getListNodesHandlers(),
+      ...getTableNodesHandlers(),
+
+      'change-start': {
+        // custom(state) {
+        //   state.textMarks.add({
+        //     markName: 'change',
+        //     markAttributes: {},
+        //   });
+        // },
+      },
+      'change-end': {
+        // custom(state) {
+        //   state.textMarks.forEach((x) =>
+        //     x.markName === 'change' ? state.textMarks.delete(x) : x
+        //   );
+        // },
+      },
+      'frame': (ctx: OdtStashContext, odtElement: any) => {
+        if (odtElement.object && odtElement.object['@href']) {
+          const fullPath = odtElement.object['@href'].replace(/^\.\//, '') +
+            '/content.xml';
+          if (files[fullPath]) {
+            const content = new TextDecoder().decode(files[fullPath]);
+            ctx.openNode();
+            ctx.closeNode('math', {
+              lang: 'mathml',
+              content,
+            });
+            return;
+          }
+        }
+        if (odtElement.image && odtElement.image['@href']) { // TODO links rewrite
+          const alt = odtElement.description?.value || '';
+          const src = odtElement.image['@href'];
+          ctx.openNode();
+          ctx.closeNode('image', {
+            src,
+            alt,
+          });
+        }
+      },
+
+      'annotation': () => {
+        // ignore: true,
+      },
+    };
+
+    const ctx = new OdtStashContext(
+      this.schema,
+      handlers,
+      stylesTree,
+      contentTree['automatic-styles'],
+    );
+
+    ctx.openNode();
+    ctx.handle('body', contentTree.body);
+    return ctx.closeNode('doc');
+  }
+}

package/src/lists.ts

@@ -0,0 +1,35 @@
+import { OdtElement } from './OdtParser.js';
+
+export class ListNumbering {
+  levels: { [level: number]: number } = {};
+  levelNodes: { [level: number]: Node } = {};
+
+  constructor() {
+    for (let i = 0; i < 20; i++) {
+      this.levels[i] = 1;
+    }
+  }
+
+  clearAbove(level: number) {
+    for (let i = level + 1; i < 20; i++) {
+      this.levels[i] = 1;
+    }
+  }
+
+  setLevelNode(level: number, node: Node) {
+    this.levelNodes[level] = node;
+  }
+}
+
+export interface List {
+  level: number;
+  odtElement: OdtElement;
+}
+
+export class ListTracker {
+  listStack: List[] = [];
+
+  listNumberings: Map<string, ListNumbering> = new Map<string, ListNumbering>();
+  lastNumbering?: ListNumbering;
+  preserveMinLevel = 999;
+}

package/src/node_handlers/basic_node_handlers.ts

@@ -0,0 +1,155 @@
+import { iterateChildren, NodeHandler, OdtStashContext } from '../OdtParser.js';
+
+export function getInlineNodesHandlers(): Record<string, NodeHandler> {
+  return {
+    '$text': (ctx: OdtStashContext, value: any) => {
+      const node = ctx.createText(value);
+      if (node) {
+        ctx.current.content.push(node);
+      }
+    },
+    's': (ctx: OdtStashContext, odtElement: any) => {
+      const chars = odtElement['@c'] || 1;
+      const text = ' '.repeat(chars);
+      const node = ctx.createText(text);
+      if (node) {
+        ctx.current.content.push(node);
+      }
+    },
+    'tab': (ctx: OdtStashContext, odtElement: any) => {
+      const node = ctx.createText('\t');
+      if (node) {
+        ctx.current.content.push(node);
+      }
+    },
+    'rect': (ctx: OdtStashContext, odtElement: any) => {
+      // if (odtElement['@rel-width'] === '100%') {
+      //   ctx.openNode();
+      //   ctx.closeNode('hr');
+      // }
+    },
+    'line-break': (ctx: OdtStashContext, odtElement: any) => {
+      ctx.openNode();
+      ctx.closeNode('br');
+    },
+    'soft-page-break': (ctx: OdtStashContext, odtElement: any) => {
+      ctx.openNode();
+      ctx.closeNode('br');
+    },
+
+    'bookmark': (ctx: OdtStashContext, element: any) => { // bookmark for parent para
+      ctx.openNode();
+      ctx.closeNode('bookmark-node', {
+        id: element['@name'],
+      });
+    },
+    'bookmark-start': (ctx: OdtStashContext, element: any) => {
+      // state.textMarks.add({
+      //   markName: 'bookmark',
+      //   markAttributes: {
+      //     id: element['@name'],
+      //   },
+      // });
+    },
+    'bookmark-end': (ctx: OdtStashContext, element: any) => {
+      // state.textMarks.forEach((x) =>
+      //   x.markName === 'bookmark' &&
+      //     x.markAttributes.id === element['@name']
+      //     ? state.textMarks.delete(x)
+      //     : x
+      // );
+    },
+  };
+}
+
+export function getBasicNodesHandlers(): Record<string, NodeHandler> {
+  return {
+    'body': (ctx: OdtStashContext, value: any) => {
+      ctx.handle('text', value.text);
+    },
+    'text': (ctx: OdtStashContext, value: any) => {
+      iterateChildren(
+        value.$value,
+        (child) => ctx.handle(child.tag, child.value),
+      );
+    },
+    'p': (ctx: OdtStashContext, value: any) => {
+      const attrs = {};
+
+      const style = ctx.getElementStyle(value);
+      const heading = style.styles.find((item) =>
+        item.startsWith('Heading_20_')
+      );
+      if (heading) {
+        attrs.level = parseInt(heading.substring('Heading_20_'.length));
+      }
+
+      let nodeType = 'paragraph';
+      if (style.styles.find((item) => item.startsWith('Heading_20_'))) {
+        nodeType = 'heading';
+      }
+
+      ctx.openNode();
+      const marks = ctx.styleToMarks(style);
+      if (marks.length > 0) {
+        ctx.current.marks = [...ctx.current.marks, ...marks];
+      }
+
+      iterateChildren(value.$value, (child) => {
+        ctx.handle(child.tag, child.value);
+      });
+
+      ctx.closeNode(nodeType, attrs);
+    },
+
+    'table-of-content': (ctx: OdtStashContext, value: any) => {
+      ctx.openNode();
+      for (const pElem of value['index-body']['p']) {
+        ctx.openNode();
+        ctx.handle('p', pElem);
+        ctx.closeNode('list_item');
+      }
+      ctx.closeNode('bullet_list');
+    },
+
+    'span': (ctx: OdtStashContext, value: any) => {
+      const style = ctx.getElementStyle(value);
+
+      const marks = ctx.styleToMarks(style);
+      if (marks.length > 0) {
+        ctx.stash();
+        ctx.current.marks = [...ctx.current.marks, ...marks];
+      }
+
+      iterateChildren(value.$value, (child) => {
+        ctx.handle(child.tag, child.value);
+      });
+
+      if (marks.length > 0) {
+        ctx.unstash();
+      }
+    },
+    'a': (ctx: OdtStashContext, value: any) => {
+      const attrs = {
+        href: value['@href'],
+        // title: tok.attrGet('title') || null,
+      };
+
+      const markType = ctx.schema.mark('link', attrs);
+
+      const marks = [markType];
+      if (marks.length > 0) {
+        ctx.stash();
+        ctx.current.marks = [...ctx.current.marks, ...marks];
+      }
+
+      iterateChildren(value.$value, (child) => {
+        ctx.handle(child.tag, child.value);
+      });
+
+      if (marks.length > 0) {
+        ctx.unstash();
+      }
+    },
+  };
+}

package/src/node_handlers/list_node_handlers.ts

@@ -0,0 +1,131 @@
+import { ListNumbering } from '../lists.js';
+import {
+  iterateChildren,
+  NodeHandler,
+  OdtStashContext,
+  resolveStyle,
+} from '../OdtParser.js';
+
+export function getListNodesHandlers(): Record<string, NodeHandler> {
+  return {
+    'list': (ctx: OdtStashContext, odtElement: any) => {
+      const listTracker = ctx.listTracker;
+      const list = {
+        level: listTracker.listStack.length + 1,
+        odtElement,
+      };
+      listTracker.listStack.push(list);
+
+      let style = {};
+      let listId = null;
+      for (let i = listTracker.listStack.length - 1; i >= 0; i--) {
+        const element = listTracker.listStack[i].odtElement;
+        if (!listId) {
+          if (element['@id']) {
+            listId = element['@id'];
+          }
+        }
+        if (!style['@style-name']) {
+          style = ('object' === typeof element && element['@style-name'])
+            ? resolveStyle(
+              ctx.stylesTree,
+              ctx.automaticStyles,
+              element['@style-name'],
+            )
+            : {};
+        }
+      }
+
+      let nodeTypeName = 'bullet_list';
+      const attrs = {};
+      if (style) {
+        const numLevelStyle = style['list-level-style-number'].find(
+          (levelStyle) => parseInt(levelStyle['@level']) === list.level,
+        );
+        if (numLevelStyle) {
+          attrs['type'] = numLevelStyle['@num-format'] || '1';
+          nodeTypeName = 'ordered_list';
+        }
+      }
+
+      ctx.current.meta['list_type'] = nodeTypeName;
+
+      let listNumbering = null;
+
+      if (listId && listTracker.listNumberings.has(listId)) {
+        listNumbering = listTracker.listNumberings.get(listId);
+      }
+
+      let isContinue = false;
+      if (
+        odtElement['@continue-list'] &&
+        listTracker.listNumberings.has(odtElement['@continue-list'])
+      ) {
+        listNumbering = listTracker.listNumberings.get(
+          odtElement['@continue-list'],
+        );
+        isContinue = true;
+      }
+      if (odtElement['@continue-numbering']) {
+        listNumbering = listTracker.lastNumbering;
+        isContinue = true;
+      }
+
+      if (!listNumbering) {
+        listNumbering = new ListNumbering();
+      }
+
+      if (isContinue) {
+        listTracker.preserveMinLevel = 999;
+      }
+
+      if (listId) {
+        listTracker.listNumberings.set(listId, listNumbering);
+      }
+
+      listTracker.lastNumbering = listNumbering;
+
+      if (listTracker.preserveMinLevel <= list.level) {
+        listNumbering.clearAbove(list.level - 1);
+      }
+
+      if (nodeTypeName === 'ordered_list') {
+        attrs['start'] = listNumbering.levels[list.level] || 1;
+      }
+
+      ctx.openNode();
+
+      const children = odtElement['list-item'].map((item) => ({
+        'list-item': item,
+      }));
+
+      if (children) {
+        iterateChildren(children, (child) => {
+          ctx.handle(child.tag, child.value);
+        });
+
+        listNumbering.levels[list.level] += children.length;
+      }
+
+      ctx.closeNode(nodeTypeName, attrs);
+
+      if (listTracker.preserveMinLevel >= list.level) {
+        listTracker.preserveMinLevel = list.level;
+      }
+
+      listTracker.listStack.pop();
+    },
+    'list-item': (ctx: OdtStashContext, odtElement: any) => {
+      ctx.openNode();
+      iterateChildren(
+        odtElement.$value,
+        (child) => ctx.handle(child.tag, child.value),
+      );
+
+      const attrs = {};
+      attrs.markup = '* ';
+
+      ctx.closeNode('list_item', attrs);
+    },
+  };
+}

package/src/node_handlers/table_node_handlers.ts

@@ -0,0 +1,28 @@
+import { iterateChildren, NodeHandler, OdtStashContext } from '../OdtParser.js';
+
+export function getTableNodesHandlers(): Record<string, NodeHandler> {
+  return {
+    'table': (ctx: OdtStashContext, value: any) => {
+      ctx.openNode();
+      for (const item of value['table-row']) {
+        ctx.handle('table-row', item);
+      }
+      ctx.closeNode('table');
+    },
+    'table-row': (ctx: OdtStashContext, value: any) => {
+      ctx.openNode();
+      for (const item of value['table-cell']) {
+        ctx.handle('table-cell', item);
+      }
+      ctx.closeNode('table_row');
+    },
+    'table-cell': (ctx: OdtStashContext, value: any) => {
+      ctx.openNode();
+      iterateChildren(
+        value.$value,
+        (child) => ctx.handle(child.tag, child.value),
+      );
+      ctx.closeNode('table_cell');
+    },
+  };
+}