@adminforth/rich-editor 1.0.18 → 1.2.0

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

@@ -1,43 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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;