quill-table-up 3.1.2 → 3.2.1

package/src/types.d.ts

@@ -1,4 +1,4 @@
-declare module '*.svg' {
-  const content: string;
-  export default content;
-}
+declare module '*.svg' {
+  const content: string;
+  export default content;
+}

package/src/utils/bem.ts

@@ -1,23 +1,23 @@
-import { cssNamespace } from './constants';
-
-export function createBEM(b: string, n: string = cssNamespace) {
-  const prefix = n ? `${n}-` : '';
-  return {
-    /** n-b */
-    b: () => `${prefix}${b}`,
-    /** n-b__e */
-    be: (e?: string) => e ? `${prefix}${b}__${e}` : '',
-    /** n-b--m */
-    bm: (m?: string) => m ? `${prefix}${b}--${m}` : '',
-    /** n-b__e--m */
-    bem: (e?: string, m?: string) => e && m ? `${prefix}${b}__${e}--${m}` : '',
-    /** n-s */
-    ns: (s?: string) => s ? `${prefix}${s}` : '',
-    /** n-b-s */
-    bs: (s?: string) => s ? `${prefix}${b}-${s}` : '',
-    /** --n-v */
-    cv: (v?: string) => v ? `--${prefix}${v}` : '',
-    /** is-n */
-    is: (n: string) => `is-${n}`,
-  };
-}
+import { cssNamespace } from './constants';
+
+export function createBEM(b: string, n: string = cssNamespace) {
+  const prefix = n ? `${n}-` : '';
+  return {
+    /** n-b */
+    b: () => `${prefix}${b}`,
+    /** n-b__e */
+    be: (e?: string) => e ? `${prefix}${b}__${e}` : '',
+    /** n-b--m */
+    bm: (m?: string) => m ? `${prefix}${b}--${m}` : '',
+    /** n-b__e--m */
+    bem: (e?: string, m?: string) => e && m ? `${prefix}${b}__${e}--${m}` : '',
+    /** n-s */
+    ns: (s?: string) => s ? `${prefix}${s}` : '',
+    /** n-b-s */
+    bs: (s?: string) => s ? `${prefix}${b}-${s}` : '',
+    /** --n-v */
+    cv: (v?: string) => v ? `--${prefix}${v}` : '',
+    /** is-n */
+    is: (n: string) => `is-${n}`,
+  };
+}

package/src/utils/blot-helper.ts

@@ -1,105 +1,101 @@
-import type { Parchment as TypeParchment } from 'quill';
-import type { TableBodyFormat, TableCellFormat, TableCellInnerFormat, TableColFormat, TableColgroupFormat, TableMainFormat, TableRowFormat, TableWrapperFormat } from '../formats';
-import type { blotName } from './constants';
-import type { Constructor } from './types';
-
-interface ParentBlotReturnMap {
-  [blotName.tableWrapper]: TableWrapperFormat;
-  [blotName.tableMain]: TableMainFormat;
-  [blotName.tableCol]: TableColFormat;
-  [blotName.tableColgroup]: TableColgroupFormat;
-  [blotName.tableBody]: TableBodyFormat;
-  [blotName.tableRow]: TableRowFormat;
-  [blotName.tableCell]: TableCellFormat;
-  [blotName.tableCellInner]: TableCellInnerFormat;
-}
-type ParentBlotReturn = {
-  [key: string]: TypeParchment.Parent;
-} & ParentBlotReturnMap;
-
-export function findParentBlot<T extends TypeParchment.Parent, U extends string = string>(
-  blot: TypeParchment.Blot,
-  targetBlotName: U,
-): U extends keyof ParentBlotReturn ? ParentBlotReturn[U] : T {
-  let target = blot.parent;
-  while (target && target.statics.blotName !== targetBlotName && target !== blot.scroll) {
-    target = target.parent;
-  }
-  if (target === blot.scroll) {
-    throw new Error(`${blot.statics.blotName} must be a child of ${targetBlotName}`);
-  }
-  return target as any;
-}
-
-export function findParentBlots<T extends (keyof ParentBlotReturnMap | string)[]>(
-  blot: TypeParchment.Blot,
-  targetBlotNames: T,
-): { [K in keyof T]: ParentBlotReturn[T[K]] } {
-  const resultBlots: TypeParchment.Parent[] = new Array(targetBlotNames.length);
-  const blotNameIndexMaps = new Map<string, number>(targetBlotNames.map((name, i) => [name, i]));
-  let target = blot.parent;
-  while (target && target !== blot.scroll) {
-    if (blotNameIndexMaps.size === 0) break;
-    if (blotNameIndexMaps.has(target.statics.blotName)) {
-      const index = blotNameIndexMaps.get(target.statics.blotName)!;
-      resultBlots[index] = target;
-      blotNameIndexMaps.delete(target.statics.blotName);
-    }
-    target = target.parent;
-  }
-  if (blotNameIndexMaps.size > 0) {
-    throw new Error(`${blot.statics.blotName} must be a child of ${Array.from(blotNameIndexMaps.keys()).join(', ')}`);
-  }
-  return resultBlots as any;
-}
-
-export function findAllParentBlot(Blot: TypeParchment.Blot) {
-  const blots: Map<string, TypeParchment.Blot> = new Map();
-  let target = Blot;
-  while (target && target.statics.blotName !== 'scroll') {
-    blots.set(target.statics.blotName, target);
-    target = target.parent;
-  }
-  return blots;
-}
-
-export function findChildBlot<T extends TypeParchment.BlotConstructor>(parent: TypeParchment.Parent, blot: T) {
-  const descendants: InstanceType<T>[] = [];
-  const next = parent.children.iterator();
-  let cur: TypeParchment.Blot | null = null;
-  while ((cur = next())) {
-    if (cur instanceof blot) {
-      descendants.push(cur as InstanceType<T>);
-    }
-  }
-  return descendants;
-}
-
-function mixinProps<T = any, U = any>(target: T, source: U, excludeReg?: RegExp) {
-  for (const prop of Object.getOwnPropertyNames(source)) {
-    if (excludeReg && excludeReg.test(prop)) continue;
-    Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop)!);
-  }
-  return target;
-}
-export function mixinClass<
-  T extends Constructor,
-  U extends Constructor[],
->(
-  base: T,
-  mixins: U,
-): T & Omit<U[number], 'constructor' | keyof InstanceType<T>> {
-  const targetClass: any = class extends base {
-    constructor(...props: any[]) {
-      super(...props);
-    }
-  };
-  for (const source of mixins) {
-    mixinProps(targetClass.prototype, source.prototype, /^constructor$/);
-  }
-
-  return targetClass;
-}
-export function isSubclassOf(childClass: any, parentClass: any): boolean {
-  return childClass.prototype && childClass.prototype instanceof parentClass;
-}
+import type { Parchment as TypeParchment } from 'quill';
+import type { TableBodyFormat, TableCellFormat, TableCellInnerFormat, TableColFormat, TableColgroupFormat, TableMainFormat, TableRowFormat, TableWrapperFormat } from '../formats';
+import type { blotName } from './constants';
+import type { Constructor } from './types';
+
+interface ParentBlotReturnMap {
+  [blotName.tableWrapper]: TableWrapperFormat;
+  [blotName.tableMain]: TableMainFormat;
+  [blotName.tableCol]: TableColFormat;
+  [blotName.tableColgroup]: TableColgroupFormat;
+  [blotName.tableBody]: TableBodyFormat;
+  [blotName.tableRow]: TableRowFormat;
+  [blotName.tableCell]: TableCellFormat;
+  [blotName.tableCellInner]: TableCellInnerFormat;
+}
+type ParentBlotReturn = {
+  [key: string]: TypeParchment.Parent;
+} & ParentBlotReturnMap;
+
+export function findParentBlot<T extends TypeParchment.Parent, U extends string = string>(
+  blot: TypeParchment.Blot,
+  targetBlotName: U,
+): U extends keyof ParentBlotReturn ? ParentBlotReturn[U] : T {
+  let target = blot.parent;
+  while (target && target.statics.blotName !== targetBlotName && target !== blot.scroll) {
+    target = target.parent;
+  }
+  if (target === blot.scroll) {
+    throw new Error(`${blot.statics.blotName} must be a child of ${targetBlotName}`);
+  }
+  return target as any;
+}
+
+export function findParentBlots<T extends (keyof ParentBlotReturnMap | string)[]>(
+  blot: TypeParchment.Blot,
+  targetBlotNames: T,
+): { [K in keyof T]: ParentBlotReturn[T[K]] } {
+  const resultBlots: TypeParchment.Parent[] = new Array(targetBlotNames.length);
+  const blotNameIndexMaps = new Map<string, number>(targetBlotNames.map((name, i) => [name, i]));
+  let target = blot.parent;
+  while (target && target !== blot.scroll) {
+    if (blotNameIndexMaps.size === 0) break;
+    if (blotNameIndexMaps.has(target.statics.blotName)) {
+      const index = blotNameIndexMaps.get(target.statics.blotName)!;
+      resultBlots[index] = target;
+      blotNameIndexMaps.delete(target.statics.blotName);
+    }
+    target = target.parent;
+  }
+  if (blotNameIndexMaps.size > 0) {
+    throw new Error(`${blot.statics.blotName} must be a child of ${Array.from(blotNameIndexMaps.keys()).join(', ')}`);
+  }
+  return resultBlots as any;
+}
+
+export function findAllParentBlot(Blot: TypeParchment.Blot) {
+  const blots: Map<string, TypeParchment.Blot> = new Map();
+  let target = Blot;
+  while (target && target.statics.blotName !== 'scroll') {
+    blots.set(target.statics.blotName, target);
+    target = target.parent;
+  }
+  return blots;
+}
+
+export function findChildBlot<T extends TypeParchment.BlotConstructor>(parent: TypeParchment.Parent, blot: T) {
+  const descendants: InstanceType<T>[] = [];
+  const next = parent.children.iterator();
+  let cur: TypeParchment.Blot | null = null;
+  while ((cur = next())) {
+    if (cur instanceof blot) {
+      descendants.push(cur as InstanceType<T>);
+    }
+  }
+  return descendants;
+}
+
+function mixinProps<T = any, U = any>(target: T, source: U, excludeReg?: RegExp) {
+  for (const prop of Object.getOwnPropertyNames(source)) {
+    if (excludeReg?.test(prop)) continue;
+    Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop)!);
+  }
+  return target;
+}
+export function mixinClass<
+  T extends Constructor,
+  U extends Constructor[],
+>(
+  base: T,
+  mixins: U,
+): T & Omit<U[number], 'constructor' | keyof InstanceType<T>> {
+  const targetClass: any = class extends base {};
+  for (const source of mixins) {
+    mixinProps(targetClass.prototype, source.prototype, /^constructor$/);
+  }
+
+  return targetClass;
+}
+export function isSubclassOf(childClass: any, parentClass: any): boolean {
+  return childClass.prototype && childClass.prototype instanceof parentClass;
+}

package/src/utils/color.ts

@@ -1,109 +1,109 @@
-export interface HSB {
-  h: number;
-  s: number;
-  b: number;
-  a: number;
-}
-export interface RGB {
-  r: number;
-  g: number;
-  b: number;
-  a: number;
-}
-function normalizeValue(value: number | string, max: number | string) {
-  value = Math.min(max as number, Math.max(0, Number.parseFloat(`${value}`)));
-
-  // Handle floating point rounding errors
-  if (Math.abs(value - (max as number)) < 0.000_001) {
-    return 1;
-  }
-
-  // Convert into [0, 1] range if it isn't already
-  return (value % (max as number)) / Number.parseFloat(max as string);
-}
-export function validateHSB(hsb: HSB): HSB {
-  return {
-    h: Math.min(360, Math.max(0, hsb.h)),
-    s: Math.min(100, Math.max(0, hsb.s)),
-    b: Math.min(100, Math.max(0, hsb.b)),
-    a: Math.min(1, Math.max(0, hsb.a)),
-  };
-}
-export function HEXtoRGB(hex: string): RGB {
-  hex = hex.startsWith('#') ? hex.slice(1) : hex;
-  const r = Number.parseInt(hex.slice(0, 2), 16);
-  const g = Number.parseInt(hex.slice(2, 4), 16);
-  const b = Number.parseInt(hex.slice(4, 6), 16);
-  const a = Number((Number.parseInt(hex.slice(6, 8) || 'ff', 16) / 255).toFixed(2));
-  return { r, g, b, a };
-}
-export function RGBtoHSB(rgb: RGB): HSB {
-  let { r, g, b, a } = rgb;
-  r = normalizeValue(r, 255);
-  g = normalizeValue(g, 255);
-  b = normalizeValue(b, 255);
-
-  const max = Math.max(r, g, b);
-  const min = Math.min(r, g, b);
-  let h: number;
-  const v = max;
-
-  const d = max - min;
-  const s = max === 0 ? 0 : d / max;
-
-  if (max === min) {
-    h = 0; // achromatic
-  }
-  else {
-    switch (max) {
-      case r: {
-        h = (g - b) / d + (g < b ? 6 : 0);
-        break;
-      }
-      case g: {
-        h = (b - r) / d + 2;
-        break;
-      }
-      case b: {
-        h = (r - g) / d + 4;
-        break;
-      }
-    }
-    h! /= 6;
-  }
-
-  return { h: h! * 360, s: s * 100, b: v * 100, a };
-}
-export function HSBtoRGB(hsb: HSB): RGB {
-  let { h, s, b, a } = hsb;
-  h = normalizeValue(h, 360) * 6;
-  s = normalizeValue(s, 100);
-  b = normalizeValue(b, 100);
-
-  const i = Math.floor(h);
-  const f = h - i;
-  const p = b * (1 - s);
-  const q = b * (1 - f * s);
-  const t = b * (1 - (1 - f) * s);
-  const mod = i % 6;
-  const r = [b, q, p, p, t, b][mod];
-  const g = [t, b, b, q, p, p][mod];
-  const v = [p, p, t, b, b, q][mod];
-
-  return {
-    r: Math.round(r * 255),
-    g: Math.round(g * 255),
-    b: Math.round(v * 255),
-    a,
-  };
-}
-export function RGBtoHEX(rgb: RGB): string {
-  const hex = [rgb.r.toString(16), rgb.g.toString(16), rgb.b.toString(16), Math.round(rgb.a * 255).toString(16)];
-  for (const key in hex) {
-    if (hex[key].length === 1) {
-      hex[key] = `0${hex[key]}`;
-    }
-  }
-  return hex.join('');
-}
-export const HSBtoHEX = (hsb: HSB): string => RGBtoHEX(HSBtoRGB(hsb));
+export interface HSB {
+  h: number;
+  s: number;
+  b: number;
+  a: number;
+}
+export interface RGB {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+}
+function normalizeValue(value: number | string, max: number | string) {
+  value = Math.min(max as number, Math.max(0, Number.parseFloat(`${value}`)));
+
+  // Handle floating point rounding errors
+  if (Math.abs(value - (max as number)) < 0.000_001) {
+    return 1;
+  }
+
+  // Convert into [0, 1] range if it isn't already
+  return (value % (max as number)) / Number.parseFloat(max as string);
+}
+export function validateHSB(hsb: HSB): HSB {
+  return {
+    h: Math.min(360, Math.max(0, hsb.h)),
+    s: Math.min(100, Math.max(0, hsb.s)),
+    b: Math.min(100, Math.max(0, hsb.b)),
+    a: Math.min(1, Math.max(0, hsb.a)),
+  };
+}
+export function HEXtoRGB(hex: string): RGB {
+  hex = hex.startsWith('#') ? hex.slice(1) : hex;
+  const r = Number.parseInt(hex.slice(0, 2), 16);
+  const g = Number.parseInt(hex.slice(2, 4), 16);
+  const b = Number.parseInt(hex.slice(4, 6), 16);
+  const a = Number((Number.parseInt(hex.slice(6, 8) || 'ff', 16) / 255).toFixed(2));
+  return { r, g, b, a };
+}
+export function RGBtoHSB(rgb: RGB): HSB {
+  let { r, g, b, a } = rgb;
+  r = normalizeValue(r, 255);
+  g = normalizeValue(g, 255);
+  b = normalizeValue(b, 255);
+
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  let h: number;
+  const v = max;
+
+  const d = max - min;
+  const s = max === 0 ? 0 : d / max;
+
+  if (max === min) {
+    h = 0; // achromatic
+  }
+  else {
+    switch (max) {
+      case r: {
+        h = (g - b) / d + (g < b ? 6 : 0);
+        break;
+      }
+      case g: {
+        h = (b - r) / d + 2;
+        break;
+      }
+      case b: {
+        h = (r - g) / d + 4;
+        break;
+      }
+    }
+    h! /= 6;
+  }
+
+  return { h: h! * 360, s: s * 100, b: v * 100, a };
+}
+export function HSBtoRGB(hsb: HSB): RGB {
+  let { h, s, b, a } = hsb;
+  h = normalizeValue(h, 360) * 6;
+  s = normalizeValue(s, 100);
+  b = normalizeValue(b, 100);
+
+  const i = Math.floor(h);
+  const f = h - i;
+  const p = b * (1 - s);
+  const q = b * (1 - f * s);
+  const t = b * (1 - (1 - f) * s);
+  const mod = i % 6;
+  const r = [b, q, p, p, t, b][mod];
+  const g = [t, b, b, q, p, p][mod];
+  const v = [p, p, t, b, b, q][mod];
+
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(v * 255),
+    a,
+  };
+}
+export function RGBtoHEX(rgb: RGB): string {
+  const hex = [rgb.r.toString(16), rgb.g.toString(16), rgb.b.toString(16), Math.round(rgb.a * 255).toString(16)];
+  for (const key in hex) {
+    if (hex[key].length === 1) {
+      hex[key] = `0${hex[key]}`;
+    }
+  }
+  return hex.join('');
+}
+export const HSBtoHEX = (hsb: HSB): string => RGBtoHEX(HSBtoRGB(hsb));

package/src/utils/components/button.ts

@@ -1,22 +1,22 @@
-import { createBEM } from '../bem';
-import { isString } from '../is';
-
-interface ButtonOptions {
-  type: 'confirm' | 'default';
-  content: HTMLElement | string;
-}
-export function createButton(options?: Partial<ButtonOptions>) {
-  const { type = 'default', content } = options || {};
-  const bem = createBEM('button');
-  const btn = document.createElement('button');
-  btn.classList.add(bem.b(), type);
-  if (content) {
-    if (isString(content)) {
-      btn.textContent = content;
-    }
-    else {
-      btn.appendChild(content);
-    }
-  }
-  return btn;
-}
+import { createBEM } from '../bem';
+import { isString } from '../is';
+
+interface ButtonOptions {
+  type: 'confirm' | 'default';
+  content: HTMLElement | string;
+}
+export function createButton(options?: Partial<ButtonOptions>) {
+  const { type = 'default', content } = options || {};
+  const bem = createBEM('button');
+  const btn = document.createElement('button');
+  btn.classList.add(bem.b(), type);
+  if (content) {
+    if (isString(content)) {
+      btn.textContent = content;
+    }
+    else {
+      btn.appendChild(content);
+    }
+  }
+  return btn;
+}