quill-table-up 3.1.2 → 3.2.1

package/src/formats/container-format.ts

@@ -1,107 +1,107 @@
-import type { Parchment as TypeParchment } from 'quill';
-import Quill from 'quill';
-import { blotName, isFunction } from '../utils';
-
-const Parchment = Quill.import('parchment');
-const Container = Quill.import('blots/container') as typeof TypeParchment.ContainerBlot;
-const Block = Quill.import('blots/block') as TypeParchment.BlotConstructor;
-const BlockEmbed = Quill.import('blots/block/embed') as TypeParchment.BlotConstructor;
-
-export class ContainerFormat extends Container {
-  static tagName: string;
-  static blotName: string = blotName.container;
-  static scope = Parchment.Scope.BLOCK_BLOT;
-  static allowedChildren?: TypeParchment.BlotConstructor[] = [Block, BlockEmbed, Container];
-  static requiredContainer: TypeParchment.BlotConstructor;
-  static defaultChild?: TypeParchment.BlotConstructor;
-
-  static allowAttrs = new Set<string>([]);
-  static allowDataAttrs = new Set<string>([]);
-  // handle the attribute change when use `setFormatValue`
-  static allowDataAttrsChangeHandler: Record<string, string> = {};
-
-  static create(_value?: unknown) {
-    const node = document.createElement(this.tagName);
-    if (this.className) {
-      node.classList.add(this.className);
-    }
-    return node;
-  }
-
-  setFormatValue(name: string, value?: any) {
-    if (this.statics.allowAttrs.has(name) || this.statics.allowDataAttrs.has(name)) {
-      let attrName = name;
-      if (this.statics.allowDataAttrs.has(name)) {
-        attrName = `data-${name}`;
-      }
-      if (value) {
-        this.domNode.setAttribute(attrName, value);
-      }
-      else {
-        this.domNode.removeAttribute(attrName);
-      }
-      const methodName = this.statics.allowDataAttrsChangeHandler[name] as keyof this;
-      if (methodName && isFunction(this[methodName])) {
-        (this[methodName] as Function)(value);
-      }
-    }
-  }
-
-  public optimize(_context: Record<string, any>) {
-    if (this.children.length === 0) {
-      if (this.statics.defaultChild != null) {
-        const child = this.scroll.create(this.statics.defaultChild.blotName);
-        this.appendChild(child);
-      }
-      else {
-        this.remove();
-      }
-    }
-
-    if (this.children.length > 0 && this.next != null && this.checkMerge()) {
-      this.next.moveChildren(this);
-      this.next.remove();
-    }
-  }
-
-  public enforceAllowedChildren(): void {
-    // the origin `enforceAllowedChildren` only unwrap the first block
-    // remove flag `done`. all block format in table container need be unwrap
-
-    // eslint-disable-next-line unicorn/no-array-for-each
-    this.children.forEach((child: TypeParchment.Blot) => {
-      const allowed = this.statics.allowedChildren.some(
-        (def: TypeParchment.BlotConstructor) => child instanceof def,
-      );
-      if (allowed) {
-        return;
-      }
-      if (child.statics.scope === Parchment.Scope.BLOCK_BLOT) {
-        // only child is in table format need keep split blot. else use the origin method
-        if (child.parent instanceof ContainerFormat) {
-          if (child.next != null) {
-            child.parent.splitAfter(child);
-          }
-          if (child.prev != null) {
-            child.parent.splitAfter(child.prev);
-          }
-        }
-        else {
-          if (child.next != null) {
-            this.splitAfter(child);
-          }
-          if (child.prev != null) {
-            this.splitAfter(child.prev);
-          }
-        }
-        child.parent.unwrap();
-      }
-      else if (child instanceof Parchment.ParentBlot) {
-        child.unwrap();
-      }
-      else {
-        child.remove();
-      }
-    });
-  }
-}
+import type { Parchment as TypeParchment } from 'quill';
+import Quill from 'quill';
+import { blotName, isFunction } from '../utils';
+
+const Parchment = Quill.import('parchment');
+const Container = Quill.import('blots/container') as typeof TypeParchment.ContainerBlot;
+const Block = Quill.import('blots/block') as TypeParchment.BlotConstructor;
+const BlockEmbed = Quill.import('blots/block/embed') as TypeParchment.BlotConstructor;
+
+export class ContainerFormat extends Container {
+  static tagName: string;
+  static blotName: string = blotName.container;
+  static scope = Parchment.Scope.BLOCK_BLOT;
+  static allowedChildren?: TypeParchment.BlotConstructor[] = [Block, BlockEmbed, Container];
+  static requiredContainer: TypeParchment.BlotConstructor;
+  static defaultChild?: TypeParchment.BlotConstructor;
+
+  static allowAttrs = new Set<string>([]);
+  static allowDataAttrs = new Set<string>([]);
+  // handle the attribute change when use `setFormatValue`
+  static allowDataAttrsChangeHandler: Record<string, string> = {};
+
+  static create(_value?: unknown) {
+    const node = document.createElement(this.tagName);
+    if (this.className) {
+      node.classList.add(this.className);
+    }
+    return node;
+  }
+
+  setFormatValue(name: string, value?: any) {
+    if (this.statics.allowAttrs.has(name) || this.statics.allowDataAttrs.has(name)) {
+      let attrName = name;
+      if (this.statics.allowDataAttrs.has(name)) {
+        attrName = `data-${name}`;
+      }
+      if (value) {
+        this.domNode.setAttribute(attrName, value);
+      }
+      else {
+        this.domNode.removeAttribute(attrName);
+      }
+      const methodName = this.statics.allowDataAttrsChangeHandler[name] as keyof this;
+      if (methodName && isFunction(this[methodName])) {
+        (this[methodName] as Function)(value);
+      }
+    }
+  }
+
+  public optimize(_context: Record<string, any>) {
+    if (this.children.length === 0) {
+      if (this.statics.defaultChild != null) {
+        const child = this.scroll.create(this.statics.defaultChild.blotName);
+        this.appendChild(child);
+      }
+      else {
+        this.remove();
+      }
+    }
+
+    if (this.children.length > 0 && this.next != null && this.checkMerge()) {
+      this.next.moveChildren(this);
+      this.next.remove();
+    }
+  }
+
+  public enforceAllowedChildren(): void {
+    // the origin `enforceAllowedChildren` only unwrap the first block
+    // remove flag `done`. all block format in table container need be unwrap
+
+    // eslint-disable-next-line unicorn/no-array-for-each
+    this.children.forEach((child: TypeParchment.Blot) => {
+      const allowed = this.statics.allowedChildren.some(
+        (def: TypeParchment.BlotConstructor) => child instanceof def,
+      );
+      if (allowed) {
+        return;
+      }
+      if (child.statics.scope === Parchment.Scope.BLOCK_BLOT) {
+        // only child is in table format need keep split blot. else use the origin method
+        if (child.parent instanceof ContainerFormat) {
+          if (child.next != null) {
+            child.parent.splitAfter(child);
+          }
+          if (child.prev != null) {
+            child.parent.splitAfter(child.prev);
+          }
+        }
+        else {
+          if (child.next != null) {
+            this.splitAfter(child);
+          }
+          if (child.prev != null) {
+            this.splitAfter(child.prev);
+          }
+        }
+        child.parent.unwrap();
+      }
+      else if (child instanceof Parchment.ParentBlot) {
+        child.unwrap();
+      }
+      else {
+        child.remove();
+      }
+    });
+  }
+}

package/src/formats/overrides/block-embed.ts

@@ -1,72 +1,72 @@
-import type { Parchment as TypeParchment } from 'quill';
-import type { BlockEmbed as TypeBlockEmbed } from 'quill/blots/block';
-import type { TableCellInnerFormat } from '../table-cell-inner-format';
-import Quill from 'quill';
-import { blotName, findParentBlot } from '../../utils';
-
-const BlockEmbed = Quill.import('blots/block/embed') as typeof TypeBlockEmbed;
-
-export class BlockEmbedOverride extends BlockEmbed {
-  delta() {
-    // if BlockEmbed is the last line of the tableCellInner. need to add value in delta
-    const delta = super.delta();
-    const formats = bubbleFormats(this);
-    if (formats[blotName.tableCellInner]) {
-      delta.insert('\n', { [blotName.tableCellInner]: formats[blotName.tableCellInner] });
-    }
-    return delta;
-  }
-
-  length() {
-    const formats = bubbleFormats(this);
-    if (formats[blotName.tableCellInner]) {
-      return super.length() + 1;
-    }
-    return super.length();
-  }
-
-  formatAt(index: number, length: number, name: string, value: unknown) {
-    if (name === blotName.tableCellInner) {
-      try {
-        const currentCellInner = findParentBlot(this, blotName.tableCellInner);
-        const newCellInner = this.scroll.create(blotName.tableCellInner, value) as TableCellInnerFormat;
-        currentCellInner.insertBefore(newCellInner, this);
-        newCellInner.appendChild(this);
-        if (currentCellInner.length() === 0) {
-          currentCellInner.remove();
-        }
-      }
-      catch {}
-    }
-    else {
-      this.format(name, value);
-    }
-  }
-}
-
-// copy from `quill/blots/block`
-function bubbleFormats(
-  blot: TypeParchment.Blot | null,
-  formats: Record<string, unknown> = {},
-  filter = true,
-): Record<string, unknown> {
-  if (blot == null) return formats;
-  if ('formats' in blot && typeof blot.formats === 'function') {
-    formats = {
-      ...formats,
-      ...blot.formats(),
-    };
-    if (filter) {
-      // exclude syntax highlighting from deltas and getFormat()
-      delete formats['code-token'];
-    }
-  }
-  if (
-    blot.parent == null
-    || blot.parent.statics.blotName === 'scroll'
-    || blot.parent.statics.scope !== blot.statics.scope
-  ) {
-    return formats;
-  }
-  return bubbleFormats(blot.parent, formats, filter);
-}
+import type { Parchment as TypeParchment } from 'quill';
+import type { BlockEmbed as TypeBlockEmbed } from 'quill/blots/block';
+import type { TableCellInnerFormat } from '../table-cell-inner-format';
+import Quill from 'quill';
+import { blotName, findParentBlot } from '../../utils';
+
+const BlockEmbed = Quill.import('blots/block/embed') as typeof TypeBlockEmbed;
+
+export class BlockEmbedOverride extends BlockEmbed {
+  delta() {
+    // if BlockEmbed is the last line of the tableCellInner. need to add value in delta
+    const delta = super.delta();
+    const formats = bubbleFormats(this);
+    if (formats[blotName.tableCellInner]) {
+      delta.insert('\n', { [blotName.tableCellInner]: formats[blotName.tableCellInner] });
+    }
+    return delta;
+  }
+
+  length() {
+    const formats = bubbleFormats(this);
+    if (formats[blotName.tableCellInner]) {
+      return super.length() + 1;
+    }
+    return super.length();
+  }
+
+  formatAt(index: number, length: number, name: string, value: unknown) {
+    if (name === blotName.tableCellInner) {
+      try {
+        const currentCellInner = findParentBlot(this, blotName.tableCellInner);
+        const newCellInner = this.scroll.create(blotName.tableCellInner, value) as TableCellInnerFormat;
+        currentCellInner.insertBefore(newCellInner, this);
+        newCellInner.appendChild(this);
+        if (currentCellInner.length() === 0) {
+          currentCellInner.remove();
+        }
+      }
+      catch {}
+    }
+    else {
+      this.format(name, value);
+    }
+  }
+}
+
+// copy from `quill/blots/block`
+function bubbleFormats(
+  blot: TypeParchment.Blot | null,
+  formats: Record<string, unknown> = {},
+  filter = true,
+): Record<string, unknown> {
+  if (blot == null) return formats;
+  if ('formats' in blot && typeof blot.formats === 'function') {
+    formats = {
+      ...formats,
+      ...blot.formats(),
+    };
+    if (filter) {
+      // exclude syntax highlighting from deltas and getFormat()
+      delete formats['code-token'];
+    }
+  }
+  if (
+    blot.parent == null
+    || blot.parent.statics.blotName === 'scroll'
+    || blot.parent.statics.scope !== blot.statics.scope
+  ) {
+    return formats;
+  }
+  return bubbleFormats(blot.parent, formats, filter);
+}

package/src/formats/overrides/block.ts

@@ -1,95 +1,95 @@
-import type { Parchment as TypeParchment } from 'quill';
-import type TypeBlock from 'quill/blots/block';
-import type { BlockEmbed as TypeBlockEmbed } from 'quill/blots/block';
-import type TypeContainer from 'quill/blots/container';
-import type { TableCellInnerFormat } from '../table-cell-inner-format';
-import Quill from 'quill';
-import { blotName, findParentBlot, isString } from '../../utils';
-import { isSameCellValue } from '../utils';
-
-const Parchment = Quill.import('parchment');
-const Block = Quill.import('blots/block') as typeof TypeBlock;
-const BlockEmbed = Quill.import('blots/block/embed') as typeof TypeBlockEmbed;
-const Container = Quill.import('blots/container') as typeof TypeContainer;
-
-export class BlockOverride extends Block {
-  replaceWith(name: string | TypeParchment.Blot, value?: any): TypeParchment.Blot {
-    const replacement = isString(name) ? this.scroll.create(name, value) : name;
-    if (replacement instanceof Parchment.ParentBlot) {
-      // replace block to TableCellInner length is 0 when setContents
-      // that will set text direct in TableCellInner but not in block
-      // so we need to set text in block and block in TableCellInner
-      // wrap with TableCellInner.formatAt when length is 0 will create a new block
-      // that can make sure TableCellInner struct correctly
-      if (replacement.statics.blotName === blotName.tableCellInner) {
-        // skip if current block already in same TableCellInner
-        let currentTableCellInner: TableCellInnerFormat | null = null;
-        try {
-          currentTableCellInner = findParentBlot(this, blotName.tableCellInner);
-          const cellValue = currentTableCellInner.formats();
-          const replacementValue = (replacement as TableCellInnerFormat).formats();
-          if (isSameCellValue(cellValue, replacementValue)) {
-            return currentTableCellInner;
-          }
-        }
-        catch {}
-
-        if (currentTableCellInner) {
-          // use TableCellInner insertBefore to find the correct position
-          currentTableCellInner.insertBefore(replacement, this);
-          replacement.appendChild(this);
-          if (currentTableCellInner.children.length === 0) {
-            currentTableCellInner.remove();
-          }
-        }
-        else {
-          // find the first parent not container
-          let currentParent = this as TypeParchment.Parent;
-          let lastParent = currentParent;
-          while (currentParent.parent !== this.scroll && currentParent.parent instanceof Container) {
-            lastParent = currentParent;
-            currentParent = currentParent.parent;
-          }
-          // if parent all container until scroll. use the last container
-          if (currentParent === this.scroll) {
-            currentParent = lastParent;
-          }
-          // split current block as a separate "line" and wrap tableCellInner
-          const index = this.offset(currentParent);
-          const length = this.length();
-          const selfParent = currentParent.isolate(index, length);
-          if (selfParent && selfParent.parent) {
-            selfParent.parent.insertBefore(replacement, selfParent.next);
-          }
-          replacement.appendChild(this);
-        }
-        return replacement;
-      }
-      else {
-        this.moveChildren(replacement);
-      }
-    }
-    if (this.parent !== null) {
-      this.parent.insertBefore(replacement, this.next);
-      this.remove();
-    }
-    this.attributes.copy(replacement as TypeParchment.BlockBlot);
-    return replacement;
-  }
-
-  format(name: string, value: any): void {
-    if (name === blotName.tableCellInner && this.parent.statics.blotName === name && !value) {
-      if (this.prev && this.prev instanceof BlockEmbed) return;
-      try {
-        const cellInner = findParentBlot(this, blotName.tableCellInner);
-        cellInner.unwrap();
-      }
-      catch {
-        console.error('unwrap TableCellInner error');
-      }
-    }
-    else {
-      super.format(name, value);
-    }
-  }
-}
+import type { Parchment as TypeParchment } from 'quill';
+import type TypeBlock from 'quill/blots/block';
+import type { BlockEmbed as TypeBlockEmbed } from 'quill/blots/block';
+import type TypeContainer from 'quill/blots/container';
+import type { TableCellInnerFormat } from '../table-cell-inner-format';
+import Quill from 'quill';
+import { blotName, findParentBlot, isString } from '../../utils';
+import { isSameCellValue } from '../utils';
+
+const Parchment = Quill.import('parchment');
+const Block = Quill.import('blots/block') as typeof TypeBlock;
+const BlockEmbed = Quill.import('blots/block/embed') as typeof TypeBlockEmbed;
+const Container = Quill.import('blots/container') as typeof TypeContainer;
+
+export class BlockOverride extends Block {
+  replaceWith(name: string | TypeParchment.Blot, value?: any): TypeParchment.Blot {
+    const replacement = isString(name) ? this.scroll.create(name, value) : name;
+    if (replacement instanceof Parchment.ParentBlot) {
+      // replace block to TableCellInner length is 0 when setContents
+      // that will set text direct in TableCellInner but not in block
+      // so we need to set text in block and block in TableCellInner
+      // wrap with TableCellInner.formatAt when length is 0 will create a new block
+      // that can make sure TableCellInner struct correctly
+      if (replacement.statics.blotName === blotName.tableCellInner) {
+        // skip if current block already in same TableCellInner
+        let currentTableCellInner: TableCellInnerFormat | null = null;
+        try {
+          currentTableCellInner = findParentBlot(this, blotName.tableCellInner);
+          const cellValue = currentTableCellInner.formats();
+          const replacementValue = (replacement as TableCellInnerFormat).formats();
+          if (isSameCellValue(cellValue, replacementValue)) {
+            return currentTableCellInner;
+          }
+        }
+        catch {}
+
+        if (currentTableCellInner) {
+          // use TableCellInner insertBefore to find the correct position
+          currentTableCellInner.insertBefore(replacement, this);
+          replacement.appendChild(this);
+          if (currentTableCellInner.children.length === 0) {
+            currentTableCellInner.remove();
+          }
+        }
+        else {
+          // find the first parent not container
+          let currentParent = this as TypeParchment.Parent;
+          let lastParent = currentParent;
+          while (currentParent.parent !== this.scroll && currentParent.parent instanceof Container) {
+            lastParent = currentParent;
+            currentParent = currentParent.parent;
+          }
+          // if parent all container until scroll. use the last container
+          if (currentParent === this.scroll) {
+            currentParent = lastParent;
+          }
+          // split current block as a separate "line" and wrap tableCellInner
+          const index = this.offset(currentParent);
+          const length = this.length();
+          const selfParent = currentParent.isolate(index, length);
+          if (selfParent?.parent) {
+            selfParent.parent.insertBefore(replacement, selfParent.next);
+          }
+          replacement.appendChild(this);
+        }
+        return replacement;
+      }
+      else {
+        this.moveChildren(replacement);
+      }
+    }
+    if (this.parent !== null) {
+      this.parent.insertBefore(replacement, this.next);
+      this.remove();
+    }
+    this.attributes.copy(replacement as TypeParchment.BlockBlot);
+    return replacement;
+  }
+
+  format(name: string, value: any): void {
+    if (name === blotName.tableCellInner && this.parent.statics.blotName === name && !value) {
+      if (this.prev && this.prev instanceof BlockEmbed) return;
+      try {
+        const cellInner = findParentBlot(this, blotName.tableCellInner);
+        cellInner.unwrap();
+      }
+      catch {
+        console.error('unwrap TableCellInner error');
+      }
+    }
+    else {
+      super.format(name, value);
+    }
+  }
+}

package/src/formats/overrides/index.ts

@@ -1,3 +1,3 @@
-export * from './block';
-export * from './block-embed';
-export * from './scroll';
+export * from './block';
+export * from './block-embed';
+export * from './scroll';