@adminforth/rich-editor 1.0.17 → 1.0.18

package/custom/node_modules/parchment/src/attributor/class.ts

@@ -0,0 +1,43 @@
+import Attributor from './attributor.js';
+
+function match(node: HTMLElement, prefix: string): string[] {
+  const className = node.getAttribute('class') || '';
+  return className
+    .split(/\s+/)
+    .filter((name) => name.indexOf(`${prefix}-`) === 0);
+}
+
+class ClassAttributor extends Attributor {
+  public static keys(node: HTMLElement): string[] {
+    return (node.getAttribute('class') || '')
+      .split(/\s+/)
+      .map((name) => name.split('-').slice(0, -1).join('-'));
+  }
+
+  public add(node: HTMLElement, value: any): boolean {
+    if (!this.canAdd(node, value)) {
+      return false;
+    }
+    this.remove(node);
+    node.classList.add(`${this.keyName}-${value}`);
+    return true;
+  }
+
+  public remove(node: HTMLElement): void {
+    const matches = match(node, this.keyName);
+    matches.forEach((name) => {
+      node.classList.remove(name);
+    });
+    if (node.classList.length === 0) {
+      node.removeAttribute('class');
+    }
+  }
+
+  public value(node: HTMLElement): any {
+    const result = match(node, this.keyName)[0] || '';
+    const value = result.slice(this.keyName.length + 1); // +1 for hyphen
+    return this.canAdd(node, value) ? value : '';
+  }
+}
+
+export default ClassAttributor;

package/custom/node_modules/parchment/src/attributor/store.ts

@@ -0,0 +1,79 @@
+import type { Formattable } from '../blot/abstract/blot.js';
+import Registry from '../registry.js';
+import Scope from '../scope.js';
+import Attributor from './attributor.js';
+import ClassAttributor from './class.js';
+import StyleAttributor from './style.js';
+
+class AttributorStore {
+  private attributes: { [key: string]: Attributor } = {};
+  private domNode: HTMLElement;
+
+  constructor(domNode: HTMLElement) {
+    this.domNode = domNode;
+    this.build();
+  }
+
+  public attribute(attribute: Attributor, value: any): void {
+    // verb
+    if (value) {
+      if (attribute.add(this.domNode, value)) {
+        if (attribute.value(this.domNode) != null) {
+          this.attributes[attribute.attrName] = attribute;
+        } else {
+          delete this.attributes[attribute.attrName];
+        }
+      }
+    } else {
+      attribute.remove(this.domNode);
+      delete this.attributes[attribute.attrName];
+    }
+  }
+
+  public build(): void {
+    this.attributes = {};
+    const blot = Registry.find(this.domNode);
+    if (blot == null) {
+      return;
+    }
+    const attributes = Attributor.keys(this.domNode);
+    const classes = ClassAttributor.keys(this.domNode);
+    const styles = StyleAttributor.keys(this.domNode);
+    attributes
+      .concat(classes)
+      .concat(styles)
+      .forEach((name) => {
+        const attr = blot.scroll.query(name, Scope.ATTRIBUTE);
+        if (attr instanceof Attributor) {
+          this.attributes[attr.attrName] = attr;
+        }
+      });
+  }
+
+  public copy(target: Formattable): void {
+    Object.keys(this.attributes).forEach((key) => {
+      const value = this.attributes[key].value(this.domNode);
+      target.format(key, value);
+    });
+  }
+
+  public move(target: Formattable): void {
+    this.copy(target);
+    Object.keys(this.attributes).forEach((key) => {
+      this.attributes[key].remove(this.domNode);
+    });
+    this.attributes = {};
+  }
+
+  public values(): { [key: string]: any } {
+    return Object.keys(this.attributes).reduce(
+      (attributes: { [key: string]: any }, name: string) => {
+        attributes[name] = this.attributes[name].value(this.domNode);
+        return attributes;
+      },
+      {},
+    );
+  }
+}
+
+export default AttributorStore;

package/custom/node_modules/parchment/src/attributor/style.ts

@@ -0,0 +1,44 @@
+import Attributor from './attributor.js';
+
+function camelize(name: string): string {
+  const parts = name.split('-');
+  const rest = parts
+    .slice(1)
+    .map((part: string) => part[0].toUpperCase() + part.slice(1))
+    .join('');
+  return parts[0] + rest;
+}
+
+class StyleAttributor extends Attributor {
+  public static keys(node: HTMLElement): string[] {
+    return (node.getAttribute('style') || '').split(';').map((value) => {
+      const arr = value.split(':');
+      return arr[0].trim();
+    });
+  }
+
+  public add(node: HTMLElement, value: any): boolean {
+    if (!this.canAdd(node, value)) {
+      return false;
+    }
+    // @ts-expect-error Fix me later
+    node.style[camelize(this.keyName)] = value;
+    return true;
+  }
+
+  public remove(node: HTMLElement): void {
+    // @ts-expect-error Fix me later
+    node.style[camelize(this.keyName)] = '';
+    if (!node.getAttribute('style')) {
+      node.removeAttribute('style');
+    }
+  }
+
+  public value(node: HTMLElement): any {
+    // @ts-expect-error Fix me later
+    const value = node.style[camelize(this.keyName)];
+    return this.canAdd(node, value) ? value : '';
+  }
+}
+
+export default StyleAttributor;

package/custom/node_modules/parchment/src/blot/abstract/blot.ts

@@ -0,0 +1,128 @@
+import type LinkedList from '../../collection/linked-list.js';
+import type LinkedNode from '../../collection/linked-node.js';
+import type { RegistryDefinition } from '../../registry.js';
+import Scope from '../../scope.js';
+
+export interface BlotConstructor {
+  new (...args: any[]): Blot;
+  /**
+   * Creates corresponding DOM node
+   */
+  create(value?: any): Node;
+
+  blotName: string;
+  tagName: string | string[];
+  scope: Scope;
+  className?: string;
+
+  requiredContainer?: BlotConstructor;
+  allowedChildren?: BlotConstructor[];
+  defaultChild?: BlotConstructor;
+}
+
+/**
+ * Blots are the basic building blocks of a Parchment document.
+ *
+ * Several basic implementations such as Block, Inline, and Embed are provided.
+ * In general you will want to extend one of these, instead of building from scratch.
+ * After implementation, blots need to be registered before usage.
+ *
+ * At the very minimum a Blot must be named with a static blotName and associated with either a tagName or className.
+ * If a Blot is defined with both a tag and class, the class takes precedence, but the tag may be used as a fallback.
+ * Blots must also have a scope, which determine if it is inline or block.
+ */
+export interface Blot extends LinkedNode {
+  scroll: Root;
+  parent: Parent;
+  prev: Blot | null;
+  next: Blot | null;
+  domNode: Node;
+
+  statics: BlotConstructor;
+
+  attach(): void;
+  clone(): Blot;
+  detach(): void;
+  isolate(index: number, length: number): Blot;
+
+  /**
+   * For leaves, length of blot's value()
+   * For parents, sum of children's values
+   */
+  length(): number;
+
+  /**
+   * Returns offset between this blot and an ancestor's
+   */
+  offset(root?: Blot): number;
+  remove(): void;
+  replaceWith(name: string, value: any): Blot;
+  replaceWith(replacement: Blot): Blot;
+  split(index: number, force?: boolean): Blot | null;
+  wrap(name: string, value?: any): Parent;
+  wrap(wrapper: Parent): Parent;
+
+  deleteAt(index: number, length: number): void;
+  formatAt(index: number, length: number, name: string, value: any): void;
+  insertAt(index: number, value: string, def?: any): void;
+
+  /**
+   * Called after update cycle completes. Cannot change the value or length
+   * of the document, and any DOM operation must reduce complexity of the DOM
+   * tree. A shared context object is passed through all blots.
+   */
+  optimize(context: { [key: string]: any }): void;
+  optimize(mutations: MutationRecord[], context: { [key: string]: any }): void;
+
+  /**
+   * Called when blot changes, with the mutation records of its change.
+   * Internal records of the blot values can be updated, and modifications of
+   * the blot itself is permitted. Can be trigger from user change or API call.
+   * A shared context object is passed through all blots.
+   */
+  update(mutations: MutationRecord[], context: { [key: string]: any }): void;
+}
+
+export interface Parent extends Blot {
+  children: LinkedList<Blot>;
+  domNode: HTMLElement;
+
+  appendChild(child: Blot): void;
+  descendant<T>(type: new () => T, index: number): [T, number];
+  descendant<T>(matcher: (blot: Blot) => boolean, index: number): [T, number];
+  descendants<T>(type: new () => T, index: number, length: number): T[];
+  descendants<T>(
+    matcher: (blot: Blot) => boolean,
+    index: number,
+    length: number,
+  ): T[];
+  insertBefore(child: Blot, refNode?: Blot | null): void;
+  moveChildren(parent: Parent, refNode?: Blot | null): void;
+  path(index: number, inclusive?: boolean): [Blot, number][];
+  removeChild(child: Blot): void;
+  unwrap(): void;
+}
+
+export interface Root extends Parent {
+  create(input: Node | string | Scope, value?: any): Blot;
+  find(node: Node | null, bubble?: boolean): Blot | null;
+  query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+}
+
+export interface Formattable extends Blot {
+  /**
+   * Apply format to blot. Should not pass onto child or other blot.
+   */
+  format(name: string, value: any): void;
+
+  /**
+   * Return formats represented by blot, including from Attributors.
+   */
+  formats(): { [index: string]: any };
+}
+
+export interface Leaf extends Blot {
+  index(node: Node, offset: number): number;
+  position(index: number, inclusive: boolean): [Node, number];
+  value(): any;
+}

package/custom/node_modules/parchment/src/blot/abstract/container.ts

@@ -0,0 +1,48 @@
+import Scope from '../../scope.js';
+import BlockBlot from '../block.js';
+import ParentBlot from './parent.js';
+
+class ContainerBlot extends ParentBlot {
+  public static blotName = 'container';
+  public static scope = Scope.BLOCK_BLOT;
+  public static tagName: string | string[];
+
+  public prev!: BlockBlot | ContainerBlot | null;
+  public next!: BlockBlot | ContainerBlot | null;
+
+  public checkMerge(): boolean {
+    return (
+      this.next !== null && this.next.statics.blotName === this.statics.blotName
+    );
+  }
+
+  public deleteAt(index: number, length: number): void {
+    super.deleteAt(index, length);
+    this.enforceAllowedChildren();
+  }
+
+  public formatAt(
+    index: number,
+    length: number,
+    name: string,
+    value: any,
+  ): void {
+    super.formatAt(index, length, name, value);
+    this.enforceAllowedChildren();
+  }
+
+  public insertAt(index: number, value: string, def?: any): void {
+    super.insertAt(index, value, def);
+    this.enforceAllowedChildren();
+  }
+
+  public optimize(context: { [key: string]: any }): void {
+    super.optimize(context);
+    if (this.children.length > 0 && this.next != null && this.checkMerge()) {
+      this.next.moveChildren(this);
+      this.next.remove();
+    }
+  }
+}
+
+export default ContainerBlot;

package/custom/node_modules/parchment/src/blot/abstract/leaf.ts

@@ -0,0 +1,57 @@
+import Scope from '../../scope.js';
+import type { Leaf } from './blot.js';
+import ShadowBlot from './shadow.js';
+
+class LeafBlot extends ShadowBlot implements Leaf {
+  public static scope = Scope.INLINE_BLOT;
+
+  /**
+   * Returns the value represented by domNode if it is this Blot's type
+   * No checking that domNode can represent this Blot type is required so
+   * applications needing it should check externally before calling.
+   */
+  public static value(_domNode: Node): any {
+    return true;
+  }
+
+  /**
+   * Given location represented by node and offset from DOM Selection Range,
+   * return index to that location.
+   */
+  public index(node: Node, offset: number): number {
+    if (
+      this.domNode === node ||
+      this.domNode.compareDocumentPosition(node) &
+        Node.DOCUMENT_POSITION_CONTAINED_BY
+    ) {
+      return Math.min(offset, 1);
+    }
+    return -1;
+  }
+
+  /**
+   * Given index to location within blot, return node and offset representing
+   * that location, consumable by DOM Selection Range
+   */
+  public position(index: number, _inclusive?: boolean): [Node, number] {
+    const childNodes: Node[] = Array.from(this.parent.domNode.childNodes);
+    let offset = childNodes.indexOf(this.domNode);
+    if (index > 0) {
+      offset += 1;
+    }
+    return [this.parent.domNode, offset];
+  }
+
+  /**
+   * Return value represented by this blot
+   * Should not change without interaction from API or
+   * user change detectable by update()
+   */
+  public value(): any {
+    return {
+      [this.statics.blotName]: this.statics.value(this.domNode) || true,
+    };
+  }
+}
+
+export default LeafBlot;