@kerebron/editor 0.4.27 → 0.4.29

package/src/types.ts

@@ -0,0 +1,71 @@
+import type { Node as ProseMirrorNode, ParseOptions } from 'prosemirror-model';
+import type { Extension } from './Extension.js';
+import type { Mark } from './Mark.js';
+import type { Node } from './Node.js';
+
+export type AnyExtension = Extension | Node | Mark;
+export type AnyExtensionOrReq = AnyExtension | {
+  requires: Array<AnyExtensionOrReq | string>;
+};
+
+export type Content = JSONContent | JSONContent[] | null;
+
+export interface EditorConfig {
+  element: HTMLElement;
+  content: Content;
+  parseOptions: ParseOptions;
+  extensions: AnyExtensionOrReq[];
+  cdnUrl?: string;
+  uri?: string;
+  languageID?: string;
+  topNode?: string;
+  readOnly?: boolean;
+}
+
+export type JSONContent = {
+  type?: string;
+  attrs?: Record<string, any>;
+  content?: JSONContent[];
+  marks?: {
+    type: string;
+    attrs?: Record<string, any>;
+    [key: string]: any;
+  }[];
+  text?: string;
+  [key: string]: any;
+};
+
+export type Attribute<T> = {
+  fromDom?: (element: HTMLElement) => T;
+  default: T;
+  toDom?: (node: ProseMirrorNode) => T;
+};
+
+export interface TextRange {
+  from: number;
+  to: number;
+}
+
+export interface RawTextMapEntry {
+  nodeIdx: number;
+  targetRow: number;
+  targetCol: number;
+  sourceCol?: number;
+  targetPos: number;
+}
+
+export interface RawTextResult {
+  content: string;
+  rawTextMap: Array<RawTextMapEntry>;
+}
+
+export interface UrlRewriteContext {
+  type: 'IMG' | 'A';
+  dest: string; // Dest format, eg: kerebron, md, odt
+  filesMap?: Record<string, Uint8Array>;
+}
+
+export type UrlRewriter = (
+  url: string,
+  ctx: UrlRewriteContext,
+) => Promise<string>;

package/src/ui.ts

@@ -0,0 +1,35 @@
+import type { CoreEditor } from './CoreEditor.js';
+
+interface SelectParams {
+  anchor: number;
+  scrollIntoView: boolean;
+  userEvent: string;
+}
+
+export interface EditorUi {
+  showMessage(msg: string): void;
+  showError(err: Error): void;
+  focus(): void;
+  select(params: SelectParams): void;
+}
+
+export function defaultUi(editor: CoreEditor): EditorUi {
+  return {
+    showMessage(msg: string) {
+      globalThis.alert(msg);
+    },
+    showError(err: Error) {
+      globalThis.alert(err.message);
+      console.error(err);
+    },
+    focus() {
+      // editor.run.focus();
+    },
+    select({
+      anchor: number,
+      scrollIntoView: boolean,
+      userEvent: string,
+    }) {
+    },
+  };
+}

package/src/utilities/SmartOutput.ts

@@ -0,0 +1,284 @@
+export interface OutputMeta<K> {
+  pos: number;
+  rowPos: number;
+  colPos: number;
+  item?: K;
+}
+
+interface Mapping {
+  sourceNo: number;
+  sourceRowPos: number;
+  sourceColPos: number;
+}
+
+export interface SourceMap {
+  'version': 3; //  3,
+  'file': string; // "out.js",
+  'sourceRoot': string; // ""
+  'sources': Array<string>; // ["foo.js", "bar.js"],
+  'sourcesContent': Array<string>; // [null, null],
+  'names': Array<string>; // ["src", "maps", "are", "fun"],
+  'mappings': string; // "A,AAAB;;ABCDE;"
+}
+
+export class SmartOutput<K> {
+  private _rowPos = 0;
+  private _colPos = 0;
+  private _pos = 0;
+
+  private chunks: Array<string> = [];
+  private metas: Array<OutputMeta<K>> = [];
+
+  log(text: string, item?: K) {
+    if (text.length === 0) {
+      return;
+    }
+
+    this.chunks.push(text);
+
+    this.metas.push({
+      pos: this._pos,
+      colPos: this._colPos,
+      rowPos: this._rowPos,
+      item,
+    });
+
+    const lines = text.split('\n');
+
+    if (lines.length === 1) {
+      this._colPos += lines[lines.length - 1].length;
+    } else {
+      this._rowPos += lines.length - 1;
+      this._colPos = lines[lines.length - 1].length;
+    }
+    this._pos += text.length;
+  }
+
+  getMetas() {
+    return this.metas;
+  }
+
+  get chunkPos() {
+    return this.chunks.length;
+  }
+
+  rollback(pos: number) {
+    this.chunks.splice(pos);
+    this.metas.splice(pos);
+  }
+
+  get rowPos() {
+    return this._rowPos;
+  }
+
+  get colPos() {
+    return this._colPos;
+  }
+
+  get pos() {
+    return this._pos;
+  }
+
+  endsWith(text: string) {
+    return this.chunks.join('').endsWith(text);
+  }
+
+  toString() {
+    return this.chunks.join('');
+  }
+
+  getSourceMap(
+    mapper: (
+      rowPos: number,
+      colPos: number,
+      pos: number,
+      item?: K,
+    ) => Mapping | void,
+  ): SourceMap {
+    const mappingRows: Array<Array<Array<number>>> = [];
+
+    let lastRow = -1;
+    let lastCol = -1;
+
+    let prevSourceNo = 0;
+    let prevSourceRowPos = 0;
+    let prevSourceColPos = 0;
+
+    let prevColPos = 0;
+    for (const meta of this.metas) {
+      while (meta.rowPos >= mappingRows.length) {
+        mappingRows.push([]);
+      }
+
+      if (lastRow != meta.rowPos || lastCol != meta.colPos) {
+        const currentRow = mappingRows[meta.rowPos];
+
+        if (lastRow != meta.rowPos) {
+          prevColPos = 0;
+        }
+        const mapping = mapper(meta.rowPos, meta.colPos, meta.pos, meta.item);
+        if (mapping) {
+          currentRow.push([
+            meta.colPos - prevColPos,
+            mapping.sourceNo - prevSourceNo,
+            mapping.sourceRowPos - prevSourceRowPos,
+            mapping.sourceColPos - prevSourceColPos,
+          ]);
+          prevColPos = meta.colPos;
+          prevSourceNo = mapping.sourceNo;
+          prevSourceRowPos = mapping.sourceRowPos;
+          prevSourceColPos = mapping.sourceColPos;
+        }
+      }
+
+      lastRow = meta.rowPos;
+      lastCol = meta.colPos;
+    }
+
+    const mappings = mappingRows
+      .map((row) =>
+        row.map(
+          (group) => encode(group),
+        )
+          .join(',')
+      )
+      .join(';');
+
+    return {
+      version: 3,
+      file: '',
+      sourceRoot: '',
+      sources: [],
+      sourcesContent: [],
+      names: [],
+      mappings,
+    };
+  }
+}
+
+const BASE64_CHARS =
+  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function toVLQ(value: number): number[] {
+  const vlq: number[] = [];
+  const isNegative = value < 0;
+  value = Math.abs(value);
+
+  if (value === 0) {
+    vlq.push(0);
+    return vlq;
+  }
+
+  while (value > 0) {
+    let digit = value & 0x1F;
+    value >>= 5;
+    if (value > 0) {
+      digit |= 0x20;
+    }
+    vlq.push(digit);
+    if (vlq.length === 1) {
+      digit = isNegative ? (digit | 0x1) : (digit & ~0x1);
+      vlq[0] = digit;
+    }
+  }
+
+  return vlq;
+}
+
+function encodeVLQ(input: number | number[]): string {
+  const numbers = Array.isArray(input) ? input : [input];
+  let result = '';
+
+  for (const num of numbers) {
+    const vlq = toVLQ(num);
+    for (const digit of vlq) {
+      result += BASE64_CHARS[digit];
+    }
+  }
+
+  return result;
+}
+
+const char_to_integer: Record<string, number> = {};
+const integer_to_char: Record<number, string> = {};
+
+'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
+  .split('')
+  .forEach(function (char, i) {
+    char_to_integer[char] = i;
+    integer_to_char[i] = char;
+  });
+
+export function decode(string: string) {
+  let result: number[] = [];
+
+  let shift = 0;
+  let value = 0;
+
+  for (let i = 0; i < string.length; i += 1) {
+    let integer = char_to_integer[string[i]];
+
+    if (integer === undefined) {
+      throw new Error('Invalid character (' + string[i] + ')');
+    }
+
+    const has_continuation_bit = integer & 32;
+
+    integer &= 31;
+    value += integer << shift;
+
+    if (has_continuation_bit) {
+      shift += 5;
+    } else {
+      const should_negate = value & 1;
+      value >>>= 1;
+
+      if (should_negate) {
+        result.push(value === 0 ? -0x80000000 : -value);
+      } else {
+        result.push(value);
+      }
+
+      // reset
+      value = shift = 0;
+    }
+  }
+
+  return result;
+}
+
+export function encode(value: number | number[]) {
+  if (typeof value === 'number') {
+    return encode_integer(value);
+  }
+
+  let result = '';
+  for (let i = 0; i < value.length; i += 1) {
+    result += encode_integer(value[i]);
+  }
+
+  return result;
+}
+
+function encode_integer(num: number) {
+  let result = '';
+
+  if (num < 0) {
+    num = (-num << 1) | 1;
+  } else {
+    num <<= 1;
+  }
+
+  do {
+    let clamped = num & 31;
+    num >>>= 5;
+
+    if (num > 0) {
+      clamped |= 32;
+    }
+
+    result += integer_to_char[clamped];
+  } while (num > 0);
+
+  return result;
+}

package/src/utilities/createNodeFromContent.ts

@@ -0,0 +1,66 @@
+import { Fragment, Node as ProseMirrorNode, Schema } from 'prosemirror-model';
+
+import type { Content, JSONContent } from '../types.js';
+
+export type CreateNodeFromContentOptions = {
+  errorOnInvalidContent?: boolean;
+};
+
+export function createNodeFromObject(
+  content: JSONContent | ProseMirrorNode | Fragment,
+  schema: Schema,
+  options?: CreateNodeFromContentOptions,
+): ProseMirrorNode {
+  try {
+    const node = schema.nodeFromJSON(content);
+
+    if (options?.errorOnInvalidContent) {
+      node.check();
+    }
+
+    return node;
+  } catch (error) {
+    if (options?.errorOnInvalidContent) {
+      throw new Error('Invalid JSON content', {
+        cause: error as Error,
+      });
+    }
+
+    console.warn(
+      'Invalid content.',
+      'Passed value:',
+      content,
+      'Error:',
+      error,
+    );
+
+    return schema.topNodeType.createAndFill(null, [])!;
+  }
+}
+
+export function createNodeFromArray(
+  content: JSONContent[],
+  schema: Schema,
+): Fragment {
+  return Fragment.fromArray(
+    content.map((item) => schema.nodeFromJSON(item)),
+  );
+}
+
+export function createNodeFromContent(
+  content: JSONContent | ProseMirrorNode | Fragment,
+  schema: Schema,
+  options?: CreateNodeFromContentOptions,
+): ProseMirrorNode | Fragment {
+  if (content instanceof ProseMirrorNode || content instanceof Fragment) {
+    return content;
+  }
+
+  const isJSONContent = typeof content === 'object' && content !== null;
+
+  if (isJSONContent) {
+    return createNodeFromObject(content, schema, options);
+  }
+
+  return schema.topNodeType.createAndFill(null, [])!;
+}

package/src/utilities/getHtmlAttributes.ts

@@ -0,0 +1,68 @@
+import type {
+  MarkSpec,
+  Node as ProseMirrorNode,
+  NodeSpec,
+} from 'prosemirror-model';
+
+import type { Mark } from '../Mark.js';
+import type { Node } from '../Node.js';
+
+type MarkOfNode = Mark | Node;
+
+export function getHtmlAttributes(
+  extension: MarkOfNode,
+  node: ProseMirrorNode,
+) {
+  const attrs: Record<string, any> = {};
+
+  if (extension.attributes) {
+    for (const [key, value] of Object.entries(extension.attributes)) {
+      if ('undefined' !== typeof node.attrs[key]) {
+        attrs[key] = node.attrs[key];
+      } else {
+        if (value.toDom) {
+          attrs[key] = value.toDom(node);
+        } else {
+          attrs[key] = value.default;
+        }
+      }
+    }
+  }
+
+  return attrs;
+}
+
+export function setHtmlAttributes(extension: MarkOfNode, element: HTMLElement) {
+  const attrs: Record<string, any> = {};
+
+  if (extension.attributes) {
+    for (const [key, value] of Object.entries(extension.attributes)) {
+      if (value.fromDom) {
+        attrs[key] = value.fromDom(element);
+      } else {
+        attrs[key] = value.default;
+      }
+    }
+  }
+
+  return attrs;
+}
+
+export function addAttributesToSchema(
+  spec: MarkSpec | NodeSpec,
+  extension: MarkOfNode,
+) {
+  const attrs = {};
+
+  if (extension.attributes) {
+    if (!spec.attrs) {
+      spec.attrs = {};
+    }
+    for (const [key, value] of Object.entries(extension.attributes)) {
+      spec.attrs[key] = value;
+      if (!value.toDom) {
+        value.toDom = (node) => node.attrs[key];
+      }
+    }
+  }
+}

package/src/utilities/getShadowRoot.ts

@@ -0,0 +1,18 @@
+export function getShadowRoot(element?: Element): ShadowRoot | undefined {
+  let current = element;
+
+  while (current) {
+    if (current.toString() === '[object ShadowRoot]') {
+      return current as unknown as ShadowRoot;
+    }
+    if (current instanceof ShadowRoot) {
+      if (current.host) {
+        return current.host.shadowRoot || undefined;
+      }
+    }
+    current = current.parentElement ||
+      ((current instanceof ShadowRoot) ? current.host : undefined);
+  }
+
+  return undefined;
+}

package/src/utilities/mod.ts

@@ -0,0 +1,5 @@
+export * from './getHtmlAttributes.js';
+export * from './createNodeFromContent.js';
+export * from './SmartOutput.js';
+export * from './getShadowRoot.js';
+export * from './toRawTextResult.js';

package/src/utilities/toRawTextResult.ts

@@ -0,0 +1,27 @@
+import { RawTextMapEntry, RawTextResult } from '../types.js';
+
+export function toRawTextResult(content: string, nodeIdx = 0): RawTextResult {
+  const lines = content.split('\n');
+
+  const rawTextMap: Array<RawTextMapEntry> = [];
+
+  let targetPos = 0;
+  let targetRow = 0;
+  for (const line of lines) {
+    rawTextMap.push({
+      nodeIdx,
+      targetRow,
+      targetCol: 0,
+      targetPos,
+    });
+
+    targetRow++;
+    targetPos += line.length + 1;
+    nodeIdx += line.length + 1;
+  }
+
+  return {
+    content,
+    rawTextMap,
+  };
+}