fabric 7.4.0 → 7.5.0-beta.1

package/src/util/path/regex.ts

@@ -1,46 +0,0 @@
-import { reNum } from '../../parser/constants';
-
-const commaWsp = `\\s*,?\\s*`;
-
-/**
- * p for param
- * using "bad naming" here because it makes the regex much easier to read
- * p is a number that is preceded by an arbitrary number of spaces, maybe 0,
- * a comma or not, and then possibly more spaces or not.
- */
-const p = `${commaWsp}(${reNum})`;
-
-// const reMoveToCommand = `(M) ?(?:${p}${p} ?)+`;
-
-// const reLineCommand = `(L) ?(?:${p}${p} ?)+`;
-
-// const reHorizontalLineCommand = `(H) ?(?:${p} ?)+`;
-
-// const reVerticalLineCommand = `(V) ?(?:${p} ?)+`;
-
-// const reClosePathCommand = String.raw`(Z)\s*`;
-
-// const reCubicCurveCommand = `(C) ?(?:${p}${p}${p}${p}${p}${p} ?)+`;
-
-// const reCubicCurveShortcutCommand = `(S) ?(?:${p}${p}${p}${p} ?)+`;
-
-// const reQuadraticCurveCommand = `(Q) ?(?:${p}${p}${p}${p} ?)+`;
-
-// const reQuadraticCurveShortcutCommand = `(T) ?(?:${p}${p} ?)+`;
-
-export const reArcCommandPoints = `${p}${p}${p}${commaWsp}([01])${commaWsp}([01])${p}${p}`;
-// const reArcCommand = `(A) ?(?:${reArcCommandPoints} ?)+`;
-
-// export const rePathCommandGroups =
-//   `(?:(?:${reMoveToCommand})` +
-//   `|(?:${reLineCommand})` +
-//   `|(?:${reHorizontalLineCommand})` +
-//   `|(?:${reVerticalLineCommand})` +
-//   `|(?:${reClosePathCommand})` +
-//   `|(?:${reCubicCurveCommand})` +
-//   `|(?:${reCubicCurveShortcutCommand})` +
-//   `|(?:${reQuadraticCurveCommand})` +
-//   `|(?:${reQuadraticCurveShortcutCommand})` +
-//   `|(?:${reArcCommand}))`;
-
-export const rePathCommand = '[mzlhvcsqta][^mzlhvcsqta]*';

package/src/util/path/typechecks.ts

@@ -1,145 +0,0 @@
-import type {
-  TComplexParsedCommand,
-  TParsedAbsoluteArcCommand,
-  TParsedAbsoluteClosePathCommand,
-  TParsedAbsoluteCubicCurveCommand,
-  TParsedAbsoluteCubicCurveShortcutCommand,
-  TParsedAbsoluteHorizontalLineCommand,
-  TParsedAbsoluteLineCommand,
-  TParsedAbsoluteMoveToCommand,
-  TParsedAbsoluteQuadraticCurveCommand,
-  TParsedAbsoluteQuadraticCurveShortcutCommand,
-  TParsedAbsoluteVerticalLineCommand,
-  TParsedClosePathCommand,
-  TParsedLineCommand,
-  TParsedRelativeArcCommand,
-  TParsedRelativeClosePathCommand,
-  TParsedRelativeCubicCurveCommand,
-  TParsedRelativeCubicCurveShortcutCommand,
-  TParsedRelativeHorizontalLineCommand,
-  TParsedRelativeLineCommand,
-  TParsedRelativeMoveToCommand,
-  TParsedRelativeQuadraticCurveCommand,
-  TParsedRelativeQuadraticCurveShortcutCommand,
-  TParsedRelativeVerticalLineCommand,
-} from './typedefs';
-
-export function isAbsMoveToCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteMoveToCommand {
-  return cmd.length == 3 && cmd[0] == 'M';
-}
-export function isRelMoveToCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeMoveToCommand {
-  return cmd.length == 3 && cmd[0] == 'm';
-}
-
-export function isAbsLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteLineCommand {
-  return cmd.length == 3 && cmd[0] == 'L';
-}
-export function isRelLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeLineCommand {
-  return cmd.length == 3 && cmd[0] == 'l';
-}
-export function isLineCommand(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedLineCommand {
-  return isAbsLineCmd(cmd) || isRelLineCmd(cmd);
-}
-
-export function isAbsHorizontalLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteHorizontalLineCommand {
-  return cmd.length == 2 && cmd[0] == 'H';
-}
-export function isRelHorizontalLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeHorizontalLineCommand {
-  return cmd.length == 2 && cmd[0] == 'h';
-}
-
-export function isAbsVerticalLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteVerticalLineCommand {
-  return cmd.length == 2 && cmd[0] == 'V';
-}
-export function isRelVerticalLineCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeVerticalLineCommand {
-  return cmd.length == 2 && cmd[0] == 'v';
-}
-
-export function isAbsClosePathCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteClosePathCommand {
-  return cmd.length == 1 && cmd[0] == 'Z';
-}
-export function isRelClosePathCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeClosePathCommand {
-  return cmd.length == 1 && cmd[0] == 'z';
-}
-export function isClosePathCommand(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedClosePathCommand {
-  return cmd.length == 1 && (cmd[0] == 'z' || cmd[0] == 'Z');
-}
-
-export function isAbsCubicCurveCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteCubicCurveCommand {
-  return cmd.length == 7 && cmd[0] == 'C';
-}
-export function isRelCubicCurveCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeCubicCurveCommand {
-  return cmd.length == 7 && cmd[0] == 'c';
-}
-
-export function isAbsCubicCurveShortcutCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteCubicCurveShortcutCommand {
-  return cmd.length == 5 && cmd[0] == 'S';
-}
-export function isRelCubicCurveShortcutCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeCubicCurveShortcutCommand {
-  return cmd.length == 5 && cmd[0] == 's';
-}
-
-export function isAbsQuadraticCurveCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteQuadraticCurveCommand {
-  return cmd.length == 5 && cmd[0] == 'Q';
-}
-export function isRelQuadraticCurveCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeQuadraticCurveCommand {
-  return cmd.length == 5 && cmd[0] == 'q';
-}
-
-export function isAbsQuadraticCurveShortcutCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteQuadraticCurveShortcutCommand {
-  return cmd.length == 3 && cmd[0] == 'T';
-}
-export function isRelQuadraticCurveShortcutCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeQuadraticCurveShortcutCommand {
-  return cmd.length == 3 && cmd[0] == 't';
-}
-
-export function isAbsArcCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedAbsoluteArcCommand {
-  return cmd.length == 8 && cmd[0] == 'A';
-}
-export function isRelArcCmd(
-  cmd: TComplexParsedCommand,
-): cmd is TParsedRelativeArcCommand {
-  return cmd.length == 8 && cmd[0] == 'a';
-}

package/src/util/path/typedefs.ts

@@ -1,326 +0,0 @@
-import type { TRadian } from '../../typedefs';
-import type { XY, Point } from '../../Point';
-
-export type TPathSegmentInfoCommon<C extends string> = {
-  x: number;
-  y: number;
-  command?: C;
-  length: number;
-};
-
-export type TCurveInfo<C extends string> = TPathSegmentInfoCommon<C> & {
-  /**
-   * Get the Point a certain percent distance along the curve
-   * @param pct
-   */
-  iterator: (pct: number) => Point;
-  /**
-   * Get the angle to a percent
-   * @param pct
-   */
-  angleFinder: (pct: number) => number;
-  /**
-   * Total length of the curve
-   */
-  length: number;
-};
-
-export type TEndPathInfo = TPathSegmentInfoCommon<'Z'> & {
-  destX: number;
-  destY: number;
-};
-
-/**
- * Relevant info to calculate path length/points on path
- * for each command type in a simplified parsed path
- */
-export type TPathSegmentCommandInfo = {
-  M: TPathSegmentInfoCommon<'M'>;
-  L: TPathSegmentInfoCommon<'L'>;
-  C: TCurveInfo<'C'>;
-  Q: TCurveInfo<'Q'>;
-  Z: TEndPathInfo;
-};
-
-export type TPathSegmentInfo =
-  TPathSegmentCommandInfo[keyof TPathSegmentCommandInfo];
-
-/**
- * A parsed command of any length (even impossible ones)
- */
-export type TParsedCommand =
-  | [command: string]
-  | [command: string, arg1: number]
-  | [command: string, arg1: number, arg2: number]
-  | [command: string, arg1: number, arg2: number, arg3: number]
-  | [command: string, arg1: number, arg2: number, arg3: number, arg4: number]
-  | [
-      command: string,
-      arg1: number,
-      arg2: number,
-      arg3: number,
-      arg4: number,
-      arg5: number,
-    ]
-  | [
-      command: string,
-      arg1: number,
-      arg2: number,
-      arg3: number,
-      arg4: number,
-      arg5: number,
-      arg6: number,
-    ]
-  | [
-      command: string,
-      arg1: number,
-      arg2: number,
-      arg3: number,
-      arg4: number,
-      arg5: number,
-      arg6: number,
-      arg7: number,
-    ];
-
-/**
- * Command strings of any length
- */
-type TCommand1<T extends TParsedCommand> = `${T[0]}`;
-type TCommand2<T extends TParsedCommand> = `${T[0]} ${T[1]}`;
-type TCommand3<T extends TParsedCommand> = `${T[0]} ${T[1]} ${T[2]}`;
-type TCommand5<T extends TParsedCommand> =
-  `${T[0]} ${T[1]} ${T[2]} ${T[3]} ${T[4]}`;
-type TCommand7<T extends TParsedCommand> =
-  `${T[0]} ${T[1]} ${T[2]} ${T[3]} ${T[4]} ${T[5]} ${T[6]}`;
-type TCommand8<T extends TParsedCommand> =
-  `${T[0]} ${T[1]} ${T[2]} ${T[3]} ${T[4]} ${T[5]} ${T[6]} ${T[7]}`;
-
-/**
- * Begin parsed SVG path commands
- * Read about commands at {@link https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths|MDN}
- */
-export type TParsedAbsoluteMoveToCommand = [command: 'M', x: number, y: number];
-export type TParsedRelativeMoveToCommand = [
-  command: 'm',
-  dx: number,
-  dy: number,
-];
-export type TParsedMoveToCommand =
-  | TParsedAbsoluteMoveToCommand
-  | TParsedRelativeMoveToCommand;
-
-export type TMoveToCommand = TCommand3<TParsedMoveToCommand>;
-
-export type TParsedAbsoluteLineCommand = [command: 'L', x: number, y: number];
-export type TParsedRelativeLineCommand = [command: 'l', dx: number, dy: number];
-export type TParsedLineCommand =
-  | TParsedAbsoluteLineCommand
-  | TParsedRelativeLineCommand;
-
-export type TLineCommand = TCommand3<TParsedLineCommand>;
-
-export type TParsedAbsoluteHorizontalLineCommand = [command: 'H', x: number];
-export type TParsedRelativeHorizontalLineCommand = [command: 'h', dx: number];
-export type TParsedHorizontalLineCommand =
-  | TParsedAbsoluteHorizontalLineCommand
-  | TParsedRelativeHorizontalLineCommand;
-
-export type THorizontalLineCommand = TCommand2<TParsedHorizontalLineCommand>;
-
-export type TParsedAbsoluteVerticalLineCommand = [command: 'V', y: number];
-export type TParsedRelativeVerticalLineCommand = [command: 'v', dy: number];
-export type TParsedVerticalLineCommand =
-  | TParsedAbsoluteVerticalLineCommand
-  | TParsedRelativeVerticalLineCommand;
-
-export type TVerticalLineCommand = TCommand2<TParsedVerticalLineCommand>;
-
-export type TParsedAbsoluteClosePathCommand = [command: 'Z'];
-export type TParsedRelativeClosePathCommand = [command: 'z'];
-export type TParsedClosePathCommand =
-  | TParsedAbsoluteClosePathCommand
-  | TParsedRelativeClosePathCommand;
-
-export type TClosePathCommand = TCommand1<TParsedClosePathCommand>;
-
-export type TParsedAbsoluteCubicCurveCommand = [
-  command: 'C',
-  controlPoint1X: number,
-  controlPoint1Y: number,
-  controlPoint2X: number,
-  controlPoint2Y: number,
-  endX: number,
-  endY: number,
-];
-export type TParsedRelativeCubicCurveCommand = [
-  command: 'c',
-  controlPoint1DX: number,
-  controlPoint1DY: number,
-  controlPoint2DX: number,
-  controlPoint2DY: number,
-  endDX: number,
-  endDY: number,
-];
-export type TParsedCubicCurveCommand =
-  | TParsedAbsoluteCubicCurveCommand
-  | TParsedRelativeCubicCurveCommand;
-
-export type TCubicCurveCommand = TCommand7<TParsedCubicCurveCommand>;
-
-export type TParsedAbsoluteCubicCurveShortcutCommand = [
-  command: 'S',
-  controlPoint2X: number,
-  controlPoint2Y: number,
-  endX: number,
-  endY: number,
-];
-export type TParsedRelativeCubicCurveShortcutCommand = [
-  command: 's',
-  controlPoint2DX: number,
-  controlPoint2DY: number,
-  endDX: number,
-  endDY: number,
-];
-export type TParsedCubicCurveShortcutCommand =
-  | TParsedAbsoluteCubicCurveShortcutCommand
-  | TParsedRelativeCubicCurveShortcutCommand;
-
-export type TCubicCurveShortcutCommand =
-  TCommand5<TParsedCubicCurveShortcutCommand>;
-
-export type TParsedAbsoluteQuadraticCurveCommand = [
-  command: 'Q',
-  controlPointX: number,
-  controlPointY: number,
-  endX: number,
-  endY: number,
-];
-export type TParsedRelativeQuadraticCurveCommand = [
-  command: 'q',
-  controlPointDX: number,
-  controlPointDY: number,
-  endDX: number,
-  endDY: number,
-];
-export type TParsedQuadraticCurveCommand =
-  | TParsedAbsoluteQuadraticCurveCommand
-  | TParsedRelativeQuadraticCurveCommand;
-
-export type TQuadraticCurveCommand = TCommand5<TParsedQuadraticCurveCommand>;
-
-export type TParsedAbsoluteQuadraticCurveShortcutCommand = [
-  command: 'T',
-  endX: number,
-  endY: number,
-];
-export type TParsedRelativeQuadraticCurveShortcutCommand = [
-  command: 't',
-  endDX: number,
-  endDY: number,
-];
-export type TParsedQuadraticCurveShortcutCommand =
-  | TParsedAbsoluteQuadraticCurveShortcutCommand
-  | TParsedRelativeQuadraticCurveShortcutCommand;
-
-export type TQuadraticCurveShortcutCommand =
-  TCommand3<TParsedQuadraticCurveShortcutCommand>;
-
-export type TParsedAbsoluteArcCommand = [
-  command: 'A',
-  radiusX: number,
-  radiusY: number,
-  rotation: TRadian,
-  largeArc: 0 | 1,
-  sweep: 0 | 1,
-  endX: number,
-  endY: number,
-];
-export type TParsedRelativeArcCommand = [
-  command: 'a',
-  radiusX: number,
-  radiusY: number,
-  rotation: TRadian,
-  largeArc: 0 | 1,
-  sweep: 0 | 1,
-  endDX: number,
-  endDY: number,
-];
-
-export type TParsedArcCommand =
-  | TParsedAbsoluteArcCommand
-  | TParsedRelativeArcCommand;
-
-export type TArcCommandSingleFlag<T extends TParsedArcCommand> =
-  `${T[0]} ${T[1]} ${T[2]} ${T[3]} ${T[4]}${T[5]} ${T[6]} ${T[7]}`;
-export type TArcCommand =
-  | TCommand8<TParsedArcCommand>
-  | TArcCommandSingleFlag<TParsedArcCommand>;
-
-/**
- * End parsed path commands
- */
-
-/**
- * Any old valid SVG path command
- */
-export type TComplexParsedCommand =
-  | TParsedMoveToCommand
-  | TParsedLineCommand
-  | TParsedHorizontalLineCommand
-  | TParsedVerticalLineCommand
-  | TParsedClosePathCommand
-  | TParsedCubicCurveCommand
-  | TParsedCubicCurveShortcutCommand
-  | TParsedQuadraticCurveCommand
-  | TParsedQuadraticCurveShortcutCommand
-  | TParsedArcCommand;
-
-/**
- * A series of path commands
- */
-export type TComplexPathData = TComplexParsedCommand[];
-
-/**
- * Any SVG command that all Fabric functions can understand
- *
- */
-export type TSimpleParsedCommand =
-  | TParsedAbsoluteMoveToCommand
-  | TParsedAbsoluteLineCommand
-  | TParsedAbsoluteClosePathCommand
-  | TParsedAbsoluteCubicCurveCommand
-  | TParsedAbsoluteQuadraticCurveCommand;
-
-export type TSimpleParseCommandType = 'L' | 'M' | 'C' | 'Q' | 'Z';
-
-export type TComplexParsedCommandType =
-  | 'M'
-  | 'L'
-  | 'C'
-  | 'Q'
-  | 'Z'
-  | 'z'
-  | 'm'
-  | 'l'
-  | 'h'
-  | 'v'
-  | 'c'
-  | 's'
-  | 'q'
-  | 't'
-  | 'a'
-  | 'H'
-  | 'V'
-  | 'S'
-  | 'T'
-  | 'A';
-
-/**
- * A series of simple paths
- */
-export type TSimplePathData = TSimpleParsedCommand[];
-
-/**
- * A point (vector) and angle between the vector and x-axis
- */
-export type TPointAngle = XY & { angle: TRadian };

package/src/util/transform_matrix_removal.ts

@@ -1,61 +0,0 @@
-import { CENTER, SCALE_X, SCALE_Y } from '../constants';
-import type { FabricImage, ParsedPAROffsets } from '../shapes/Image';
-import type { FabricObject } from '../shapes/Object/FabricObject';
-import type { TMat2D } from '../typedefs';
-import { qrDecompose } from './misc/matrix';
-
-type FabricObjectWithTransformMatrix = FabricObject & {
-  transformMatrix?: TMat2D;
-};
-
-/**
- * This function is an helper for svg import. it decompose the transformMatrix
- * and assign properties to object.
- * untransformed coordinates
- * @private
- */
-const _assignTransformMatrixProps = (
-  object: FabricObjectWithTransformMatrix,
-) => {
-  if (object.transformMatrix) {
-    const { scaleX, scaleY, angle, skewX } = qrDecompose(
-      object.transformMatrix,
-    );
-    object.flipX = false;
-    object.flipY = false;
-    object.set(SCALE_X, scaleX);
-    object.set(SCALE_Y, scaleY);
-    object.angle = angle;
-    object.skewX = skewX;
-    object.skewY = 0;
-  }
-};
-
-/**
- * This function is an helper for svg import. it removes the transform matrix
- * and set to object properties that fabricjs can handle
- * @private
- * @param {Object} preserveAspectRatioOptions
- */
-export const removeTransformMatrixForSvgParsing = (
-  object: FabricObjectWithTransformMatrix,
-  preserveAspectRatioOptions?: ParsedPAROffsets,
-) => {
-  let center = object._findCenterFromElement();
-  if (object.transformMatrix) {
-    _assignTransformMatrixProps(object);
-    center = center.transform(object.transformMatrix);
-  }
-  delete object.transformMatrix;
-  if (preserveAspectRatioOptions) {
-    object.scaleX *= preserveAspectRatioOptions.scaleX;
-    object.scaleY *= preserveAspectRatioOptions.scaleY;
-    (object as FabricImage).cropX = preserveAspectRatioOptions.cropX;
-    (object as FabricImage).cropY = preserveAspectRatioOptions.cropY;
-    center.x += preserveAspectRatioOptions.offsetLeft;
-    center.y += preserveAspectRatioOptions.offsetTop;
-    object.width = preserveAspectRatioOptions.width;
-    object.height = preserveAspectRatioOptions.height;
-  }
-  object.setPositionByOrigin(center, CENTER, CENTER);
-};

package/src/util/typeAssertions.spec.ts

@@ -1,127 +0,0 @@
-import {
-  isTextObject,
-  isSerializableFiller,
-  isPattern,
-  isPath,
-  isFiller,
-  isActiveSelection,
-} from './typeAssertions';
-import { FabricText } from '../shapes/Text/Text';
-import { IText } from '../shapes/IText/IText';
-import { Textbox } from '../shapes/Textbox';
-import { Path } from '../shapes/Path';
-import { Pattern } from '../Pattern/Pattern';
-import { Gradient } from '../gradient/Gradient';
-import { Shadow } from '../Shadow';
-import { ActiveSelection } from '../shapes/ActiveSelection';
-import { Canvas } from '../canvas/Canvas';
-import { Group } from '../shapes/Group';
-
-import { describe, expect, test } from 'vitest';
-
-describe('typeAssertions', () => {
-  describe('isTextObject', () => {
-    test('can detect FabricText', () => {
-      const text = new FabricText('hello');
-      expect(isTextObject(text)).toBe(true);
-    });
-    test('can detect IText', () => {
-      const text = new IText('hello');
-      expect(isTextObject(text)).toBe(true);
-    });
-    test('can detect Textbox', () => {
-      const text = new Textbox('hello');
-      expect(isTextObject(text)).toBe(true);
-    });
-    test('can detect other subclasses', () => {
-      class NewText extends Textbox {
-        status = 'new';
-        static type = 'NewText';
-      }
-      const newText = new NewText('hello world');
-      expect(isTextObject(newText)).toBe(true);
-    });
-    test('can safeguard against other FabricObjects', () => {
-      const path = new Path('M 0 0 L 1 1');
-      expect(isTextObject(path)).toBe(false);
-    });
-  });
-  describe('isPath', () => {
-    test('can detect Path', () => {
-      const path = new Path('M 0 0 L 1 1');
-      expect(isPath(path)).toBe(true);
-    });
-    test('can detect other subclasses', () => {
-      class NewPath extends Path {
-        status = 'new';
-        static type = 'NewPath';
-      }
-      const newPath = new NewPath('M 0 0 L 1 1');
-      expect(isPath(newPath)).toBe(true);
-    });
-    test('can guard against other FabricObjects', () => {
-      const text = new Textbox('hello');
-      expect(isPath(text)).toBe(false);
-    });
-  });
-  describe('isPattern', () => {
-    test('can detect Pattern', () => {
-      const pattern = new Pattern({
-        source: new Image(100, 100),
-      });
-      expect(isPattern(pattern)).toBe(true);
-    });
-    test('can guard against Gradient', () => {
-      const gradient = new Gradient({ type: 'linear' });
-      expect(isPattern(gradient)).toBe(false);
-    });
-    test('can guard against Shadow', () => {
-      const shadow = new Shadow({ offsetX: 10 });
-      expect(isPattern(shadow as unknown as Pattern)).toBe(false);
-    });
-  });
-  describe('isFiller', () => {
-    test('can detect Pattern', () => {
-      const pattern = new Pattern({
-        source: new Image(100, 100),
-      });
-      expect(isFiller(pattern)).toBe(true);
-    });
-    test('can detect Gradient', () => {
-      const gradient = new Gradient({ type: 'linear' });
-      expect(isFiller(gradient)).toBe(true);
-    });
-    test('can guard against string', () => {
-      const filler = 'red';
-      expect(isFiller(filler)).toBe(false);
-    });
-    test('can guard against null', () => {
-      const filler = null;
-      expect(isFiller(filler)).toBe(false);
-    });
-  });
-  describe('isSerializableFiller', () => {
-    test('can detect Pattern', () => {
-      const pattern = new Pattern({
-        source: new Image(100, 100),
-      });
-      expect(isSerializableFiller(pattern)).toBe(true);
-    });
-    test('can detect Gradient', () => {
-      const gradient = new Gradient({ type: 'linear' });
-      expect(isSerializableFiller(gradient)).toBe(true);
-    });
-  });
-  describe('isActiveSelection', () => {
-    test('can detect activeSelection', () => {
-      const as = new ActiveSelection([], {
-        canvas: new Canvas(),
-      });
-      expect(isActiveSelection(as)).toBe(true);
-    });
-    test('can safeguard against a group', () => {
-      const group = new Group([]);
-      expect(isActiveSelection(group)).toBe(false);
-    });
-  });
-});