@edifice.io/react 2.0.0-develop-rc.3

package/dist/modules/multimedia/ImageEditor/effects/crop.d.ts

@@ -0,0 +1,28 @@
+import * as PIXI from 'pixi.js';
+export type CornerType = 'TOP_LEFT' | 'TOP_RIGHT' | 'BOTTOM_LEFT' | 'BOTTOM_RIGHT';
+/**
+ * This function draw all graphics controls used to crop an image:
+ * - 4 corners to select the cropped area
+ * - A background with an transparent backdrop effect
+ * - A mask applied to the original image
+ *
+ * @param application The PIXI.Application context
+ * @param {spriteName:string} {spriteName} The sprite name identifying the original image
+ */
+export declare function start(application: PIXI.Application, { spriteName }: {
+    spriteName: string;
+}): void;
+/**
+ * This function remove all graphics controls if exists. And it also remove any mouse event on this stage
+ *
+ * @param application The PIXI.Application context
+ */
+export declare function stop(application: PIXI.Application): void;
+/**
+ * This function apply a crop to the imageSrc and return the result as a PIXI.Sprite object
+ *
+ * @param application
+ * @param imageSrc a string URI of the image to crop
+ * @returns a PIXI.Sprite with a imageSrc cropped or undefined if the image has not been cropped
+ */
+export declare function save(application: PIXI.Application): PIXI.Sprite | undefined;

package/dist/modules/multimedia/ImageEditor/effects/crop.js

@@ -0,0 +1,155 @@
+import * as PIXI from "pixi.js";
+import { getApplicationScale } from "./misc.js";
+const CORNERS = ["TOP_LEFT", "TOP_RIGHT", "BOTTOM_LEFT", "BOTTOM_RIGHT"], PADDING = 0, POINT_RADIUS = 20, CROP_BACKGROUND_NAME = "CROP_BACKGROUND_NAME", CROP_MASK_NAME = "CROP_MASK_NAME";
+function getCornerName(corner) {
+  return "CROP_CORNER_" + corner;
+}
+function drawBackground(application, {
+  spriteName
+}) {
+  removeBackground(application);
+  const sprite = application.stage.getChildByName(spriteName);
+  if (sprite == null) return;
+  const spriteBounds = sprite.getBounds(), stageTexture = application.renderer.generateTexture(application.stage).clone(), clonedStage = new PIXI.Sprite(stageTexture);
+  clonedStage.height = spriteBounds.height, clonedStage.width = spriteBounds.width, clonedStage.position = new PIXI.Point(0, 0);
+  const background = new PIXI.Graphics();
+  background.beginFill(16777215, 0.5), background.drawRect(0, 0, spriteBounds.width, spriteBounds.height), background.endFill(), background.name = CROP_BACKGROUND_NAME, background.position = new PIXI.Point(spriteBounds.x, spriteBounds.y);
+  const rectMask = new PIXI.Graphics();
+  rectMask.beginFill(0, 1), rectMask.drawRect(0, 0, spriteBounds.width - 2 * PADDING, spriteBounds.height - 2 * PADDING), rectMask.endFill(), rectMask.position = new PIXI.Point(PADDING, PADDING), rectMask.name = CROP_MASK_NAME, clonedStage.mask = rectMask, application.stage.addChild(background), background.addChild(rectMask), background.addChild(clonedStage);
+}
+function removeBackground(application) {
+  const child = application.stage.getChildByName(CROP_BACKGROUND_NAME, !0);
+  child == null || child.removeFromParent();
+}
+function computeCornerPosition(cornerType, bounds) {
+  switch (cornerType) {
+    case "TOP_LEFT":
+      return {
+        x: bounds.x,
+        y: bounds.y,
+        start: 0,
+        end: Math.PI / 2
+      };
+    case "TOP_RIGHT":
+      return {
+        x: bounds.x + bounds.width,
+        y: bounds.y,
+        start: Math.PI / 2,
+        end: Math.PI
+      };
+    case "BOTTOM_LEFT":
+      return {
+        x: bounds.x,
+        y: bounds.y + bounds.height,
+        start: 3 * Math.PI / 2,
+        end: 2 * Math.PI
+      };
+    case "BOTTOM_RIGHT":
+      return {
+        x: bounds.x + bounds.width,
+        y: bounds.y + bounds.height,
+        start: Math.PI,
+        end: 3 * Math.PI / 2
+      };
+  }
+}
+function refreshCorners(application) {
+  const mask = application.stage.getChildByName(CROP_MASK_NAME, !0);
+  mask != null && CORNERS.forEach((cornerType) => {
+    const corner = application.stage.getChildByName(getCornerName(cornerType), !0);
+    if (corner == null) return;
+    const position = computeCornerPosition(cornerType, {
+      height: mask.height,
+      width: mask.width,
+      x: mask.x,
+      y: mask.y
+    });
+    corner.position = new PIXI.Point(position.x, position.y);
+  });
+}
+function drawCorner(application, cornerType, {
+  spriteName
+}) {
+  const previous = application.stage.getChildByName(getCornerName(cornerType), !0), scale = getApplicationScale(application);
+  previous == null || previous.removeFromParent();
+  const background = application.stage.getChildByName(CROP_BACKGROUND_NAME, !0), mask = application.stage.getChildByName(CROP_MASK_NAME, !0), sprite = application.stage.getChildByName(spriteName);
+  if (sprite == null || background === null || background === void 0 || mask === void 0 || mask === null)
+    return;
+  const position = computeCornerPosition(cornerType, {
+    height: mask.height,
+    width: mask.width,
+    x: mask.x,
+    y: mask.y
+  }), corner = new PIXI.Graphics();
+  corner.beginFill(4960213, 1), corner.arc(0, 0, POINT_RADIUS / scale, position.start, position.end), corner.lineTo(0, 0), corner.endFill(), corner.position = new PIXI.Point(position.x, position.y), corner.name = getCornerName(cornerType), corner.interactive = !0;
+  let enable = !1;
+  application.stage.on("pointermove", (event) => {
+    if (enable === !1) return;
+    const localPosition = background.toLocal(event.global);
+    corner.position.x = localPosition.x, corner.position.y = localPosition.y, moveMask(application, cornerType, localPosition);
+  });
+  const handlePointerDown = () => {
+    enable = !0;
+  };
+  corner.on("pointerdown", handlePointerDown);
+  const handlePointerUp = () => {
+    enable = !1;
+  };
+  globalThis.addEventListener("pointerup", handlePointerUp), corner.once("destroyed", () => {
+    corner.off("pointerdown"), globalThis.removeEventListener("pointerup", handlePointerUp);
+  }), background.addChild(corner);
+}
+function moveMask(application, cornerType, position) {
+  const mask = application.stage.getChildByName(CROP_MASK_NAME, !0);
+  if (mask == null) return;
+  const right = mask.position.x + mask.width, bottom = mask.position.y + mask.height;
+  switch (cornerType) {
+    case "TOP_LEFT": {
+      mask.position.x = position.x, mask.position.y = position.y, mask.width = right - position.x, mask.height = bottom - position.y;
+      break;
+    }
+    case "TOP_RIGHT": {
+      mask.position.y = position.y, mask.width = position.x - mask.position.x, mask.height = bottom - position.y;
+      break;
+    }
+    case "BOTTOM_LEFT": {
+      mask.position.x = position.x, mask.width = right - position.x, mask.height = position.y - mask.position.y;
+      break;
+    }
+    case "BOTTOM_RIGHT": {
+      mask.width = position.x - mask.position.x, mask.height = position.y - mask.position.y;
+      break;
+    }
+  }
+  refreshCorners(application);
+}
+function start(application, {
+  spriteName
+}) {
+  stop(application), application.stage.interactive = !0, application.stage.interactiveChildren = !0, drawBackground(application, {
+    spriteName
+  }), drawCorner(application, "BOTTOM_LEFT", {
+    spriteName
+  }), drawCorner(application, "BOTTOM_RIGHT", {
+    spriteName
+  }), drawCorner(application, "TOP_LEFT", {
+    spriteName
+  }), drawCorner(application, "TOP_RIGHT", {
+    spriteName
+  });
+}
+function stop(application) {
+  removeBackground(application), application.stage.off("pointermove"), application.render();
+}
+function save(application) {
+  const mask = application.stage.getChildByName(CROP_MASK_NAME, !0);
+  if (mask == null) return;
+  stop(application);
+  const stageTexture = application.renderer.generateTexture(application.stage).clone(), clonedStage = new PIXI.Sprite(stageTexture), maskBounds = mask.getBounds(), bounds = new PIXI.Rectangle(Math.floor(maskBounds.x), Math.floor(maskBounds.y), Math.floor(maskBounds.width), Math.floor(maskBounds.height)), cropped = new PIXI.Texture(clonedStage.texture.baseTexture, bounds);
+  return new PIXI.Sprite(cropped);
+}
+export {
+  save,
+  start,
+  stop
+};

package/dist/modules/multimedia/ImageEditor/effects/misc.d.ts

@@ -0,0 +1,154 @@
+import * as PIXI from 'pixi.js';
+export declare const DEFAULT_SPRITE_NAME = "image";
+/**
+ * A structure that define all setting of an image
+ * - positon
+ * - scale
+ * - size
+ * - size of the stage
+ */
+export interface ImageSettings {
+    stage: {
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+    };
+    sprite: {
+        rotation: number;
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+        position: {
+            x: number;
+            y: number;
+        };
+        anchor: {
+            x: number;
+            y: number;
+        };
+    };
+}
+/**
+ *  This function update the image content using Blob datasource
+ *
+ * @param application the PIXI.Application context
+ * @param param.spriteName the name of the sprite in the context
+ * @param param.imgDatasource the img data could be one of: string url, HTMLImageElement, PIXI.Sprite
+ * @param param.stageSize?: { width: number; height: number };
+ * @param param.spriteSize?: { width: number; height: number };
+ */
+export declare function updateImageFromBlob(application: PIXI.Application, { spriteName, imgDatasource, settings, }: {
+    spriteName: string;
+    imgDatasource: Blob;
+    settings?: ImageSettings;
+}): Promise<PIXI.Sprite | null>;
+/**
+ *  This function update the image content for the sprite in the PIXI.Application context
+ *
+ * @param application the PIXI.Application context
+ * @param param.spriteName the name of the sprite in the context
+ * @param param.imgDatasource the img data could be one of: string url, HTMLImageElement, PIXI.Sprite
+ * @param param.spriteSize
+ * @param param.stageSize
+ */
+export declare function updateImage(application: PIXI.Application, { spriteName, imgDatasource, settings, }: {
+    spriteName: string;
+    imgDatasource: string | HTMLImageElement | PIXI.Sprite;
+    settings?: ImageSettings;
+}): Promise<void>;
+/**
+ * This function resize the sprite according to the container width
+ *
+ * @param application The PIXI.Application context
+ * @param sprite The sprite object representing the image to resize
+ */
+export declare function autoResize(application: PIXI.Application, sprite: PIXI.Sprite): void;
+export declare function constraintSize(size: {
+    width: number;
+    height: number;
+}, constraints: {
+    width: {
+        max: number;
+        min: number;
+    };
+    height: {
+        max: number;
+        min: number;
+    };
+}): {
+    width: number;
+    height: number;
+};
+/**
+ * This function transform the stage into a blob
+ *
+ * @param application the PIXI.Application context
+ * @returns A promise of the generated blob
+ */
+export declare function saveAsBlob(application: PIXI.Application): Promise<Blob>;
+/**
+ * This function transform the stage into a data URL encoded image
+ *
+ * @param application the PIXI.Application context
+ * @returns the generated image as Data URL or undefined if failed
+ */
+export declare function saveAsDataURL(application: PIXI.Application): string | undefined;
+/**
+ * Calculates the scale percentage for a PIXI.Sprite or the application view based on the parent container's dimensions.
+ * @param application - The PIXI.Application instance.
+ * @param sprite - The PIXI.Sprite instance (optional).
+ * @returns The scale percentage.
+ */
+export declare function getApplicationScale(application: PIXI.Application): number;
+export declare function toBlob(application: PIXI.Application): Promise<Blob>;
+export declare function createImageSettings({ application, sprite, }: {
+    sprite: PIXI.Sprite;
+    application: PIXI.Application;
+}): {
+    sprite: {
+        rotation: number;
+        size: {
+            width: number;
+            height: number;
+        };
+        position: {
+            x: number;
+            y: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+        anchor: {
+            x: number;
+            y: number;
+        };
+    };
+    stage: {
+        size: {
+            width: number;
+            height: number;
+        };
+        scale: {
+            x: number;
+            y: number;
+        };
+    };
+};
+export declare function trimStage(application: PIXI.Application, sprite: PIXI.Sprite): void;
+export declare function resizeStage({ application, sprite, newHeight, newWidth, }: {
+    newHeight: number;
+    newWidth: number;
+    application: PIXI.Application;
+    sprite: PIXI.Sprite;
+}): void;

package/dist/modules/multimedia/ImageEditor/effects/misc.js

@@ -0,0 +1,162 @@
+import * as PIXI from "pixi.js";
+const MIN_HEIGHT = 100, MIN_WIDTH = 100, MODAL_VERTICAL_PADDING = 450, MODAL_HORIZONTAL_PADDING = 64, DEFAULT_QUALITY = 0.5, DEFAULT_SPRITE_NAME = "image";
+function updateImageFromBlob(application, {
+  spriteName,
+  imgDatasource,
+  settings
+}) {
+  const imageUrl = URL.createObjectURL(imgDatasource), image = new Image();
+  return image.src = imageUrl, new Promise((resolve) => {
+    image.onload = async () => {
+      await updateImage(application, {
+        spriteName,
+        imgDatasource: image,
+        settings
+      });
+      const newSprite = application == null ? void 0 : application.stage.getChildByName(spriteName, !0);
+      resolve(newSprite);
+    };
+  });
+}
+async function updateImage(application, {
+  spriteName,
+  imgDatasource,
+  settings
+}) {
+  if (application === void 0 || application.stage === null)
+    return;
+  const previous = application.stage.getChildByName(spriteName, !0);
+  previous == null || previous.removeFromParent();
+  const texture = imgDatasource instanceof HTMLImageElement ? PIXI.Texture.from(imgDatasource) : imgDatasource instanceof PIXI.Sprite ? imgDatasource : await PIXI.Texture.fromURL(imgDatasource), sprite = texture instanceof PIXI.Sprite ? texture : PIXI.Sprite.from(texture, {});
+  if (sprite.interactive = !0, sprite.name = spriteName, settings) {
+    const {
+      sprite: {
+        anchor,
+        position,
+        scale,
+        size: spriteSize,
+        rotation
+      },
+      stage: {
+        size: stageSize
+      }
+    } = settings, isRotated = rotation % Math.PI !== 0;
+    sprite.anchor.x = anchor.x, sprite.anchor.y = anchor.y, sprite.position.x = position.x, sprite.position.y = position.y, sprite.scale.x = scale.x, sprite.scale.y = scale.y, sprite.width = isRotated ? spriteSize.height : spriteSize.width, sprite.height = isRotated ? spriteSize.width : spriteSize.height, application.stage.height = stageSize.height, application.stage.width = stageSize.width, application.renderer.resize(stageSize.width, stageSize.height), application.stage.addChild(sprite);
+  } else
+    application.stage.addChild(sprite), application.renderer.resize(sprite.width, sprite.height);
+  autoResize(application, sprite);
+}
+function autoResize(application, sprite) {
+  var _a;
+  const parent = application.view.parentNode, maxMobileWidth = window.innerWidth - MODAL_HORIZONTAL_PADDING, parentWidth = Math.max((parent == null ? void 0 : parent.offsetWidth) ?? 0, MIN_WIDTH), newSize = constraintSize({
+    width: sprite.width,
+    height: sprite.height
+  }, {
+    width: {
+      max: Math.min(parentWidth, maxMobileWidth),
+      min: MIN_WIDTH
+    },
+    height: {
+      min: MIN_HEIGHT,
+      max: window.innerHeight - MODAL_VERTICAL_PADDING
+    }
+  }), {
+    height: newHeight,
+    width: newWidth
+  } = newSize;
+  (_a = application.view) != null && _a.style && (application.view.style.width = `${newWidth}px`, application.view.style.height = `${newHeight}px`);
+}
+function constraintSize(size, constraints) {
+  const {
+    height,
+    width
+  } = size, ratio = width / height, {
+    height: constraintHeight,
+    width: constraintWidth
+  } = constraints;
+  let newWidth = constraintWidth.max, newHeight = constraintWidth.max / ratio;
+  return width > constraintWidth.max && (newWidth = constraintWidth.max, newHeight = newWidth / ratio), newHeight > constraintHeight.max && (newHeight = constraintHeight.max, newWidth = newHeight * ratio), newWidth < constraintWidth.min && (newWidth = constraintWidth.min, newHeight = newWidth / ratio), newHeight < constraintHeight.min && (newHeight = constraintHeight.min, newWidth = newHeight * ratio), {
+    width: newWidth,
+    height: newHeight
+  };
+}
+function saveAsBlob(application) {
+  return new Promise((resolve, reject) => {
+    var _a;
+    (_a = application == null ? void 0 : application.view) != null && _a.toBlob ? application.view.toBlob((blob) => {
+      blob ? resolve(blob) : reject("EXTRACT_FAILED");
+    }, "image/jpeg", DEFAULT_QUALITY) : reject("EXTRACT_FAILED");
+  });
+}
+function saveAsDataURL(application) {
+  var _a, _b;
+  return (_b = (_a = application.view).toDataURL) == null ? void 0 : _b.call(_a);
+}
+function getApplicationScale(application) {
+  return application.view.getBoundingClientRect ? application.view.getBoundingClientRect().width / application.view.width : 1;
+}
+function toBlob(application) {
+  return new Promise((resolve, reject) => {
+    var _a, _b;
+    (_b = (_a = application.view).toBlob) == null || _b.call(_a, (blob) => {
+      blob ? resolve(blob) : reject("EXTRACT_FAIL");
+    }, "image/png", 1);
+  });
+}
+function createImageSettings({
+  application,
+  sprite
+}) {
+  return {
+    sprite: {
+      rotation: sprite.rotation,
+      size: {
+        width: sprite.width,
+        height: sprite.height
+      },
+      position: {
+        x: sprite.position.x,
+        y: sprite.position.y
+      },
+      scale: {
+        x: sprite.scale.x,
+        y: sprite.scale.y
+      },
+      anchor: {
+        x: sprite.anchor.x,
+        y: sprite.anchor.y
+      }
+    },
+    stage: {
+      size: {
+        width: application.stage.width,
+        height: application.stage.height
+      },
+      scale: {
+        x: application.stage.scale.x,
+        y: application.stage.scale.y
+      }
+    }
+  };
+}
+function resizeStage({
+  application,
+  sprite,
+  newHeight,
+  newWidth
+}) {
+  sprite.anchor.x = 0.5, sprite.anchor.y = 0.5, sprite.position = new PIXI.Point(newWidth / 2, newHeight / 2), application.stage.height = newHeight, application.stage.width = newWidth, application.renderer.resize(newWidth, newHeight);
+}
+export {
+  DEFAULT_SPRITE_NAME,
+  autoResize,
+  constraintSize,
+  createImageSettings,
+  getApplicationScale,
+  resizeStage,
+  saveAsBlob,
+  saveAsDataURL,
+  toBlob,
+  updateImage,
+  updateImageFromBlob
+};

package/dist/modules/multimedia/ImageEditor/effects/resize.d.ts

@@ -0,0 +1,25 @@
+import * as PIXI from 'pixi.js';
+/**
+ * Draw all graphical object to control the resize
+ *
+ * @param application the PIXI.Application context
+ * @param spriteName the name of the sprite representing the image
+ */
+export declare function start(application: PIXI.Application, spriteName: string): void;
+/**
+ * If {saveChanges} is true remove all graphical controls then resize the sprite
+ * If {saveChanges} is false remove all graphical controls and keep original size
+ *
+ * @param application the PIXI.Application context
+ * @param param.saveChanges true if we should save the resize
+ * @param param.spriteName the name of the sprite representing the original image
+ */
+export declare function stop(application: PIXI.Application): void;
+/**
+ *
+ * @param application the PIXI.Application context
+ * @param spriteName  the name of the sprite representing the image
+ * @param size the target size of the image {width, height}
+ * @returns a PIXI.Sprite with a image resized or undefined if not found
+ */
+export declare function save(application: PIXI.Application): PIXI.Sprite | undefined;

package/dist/modules/multimedia/ImageEditor/effects/resize.js

@@ -0,0 +1,157 @@
+import * as PIXI from "pixi.js";
+const POINT_RADIUS = 20, CONTROL_NAME = "CONTROL_NAME";
+function getCornerName(index) {
+  return "RESIZE_CORNER_" + index;
+}
+function computeCornerPosition(position, sprite) {
+  const left = sprite.x, top = sprite.y;
+  switch (position) {
+    case "TOP_LEFT":
+      return {
+        x: left,
+        y: top,
+        start: 0,
+        end: Math.PI / 2
+      };
+    case "TOP_RIGHT":
+      return {
+        x: left + sprite.width,
+        y: top,
+        start: Math.PI / 2,
+        end: Math.PI
+      };
+    case "BOTTOM_LEFT":
+      return {
+        x: left,
+        y: top + sprite.height,
+        start: 3 * Math.PI / 2,
+        end: 2 * Math.PI
+      };
+    case "BOTTOM_RIGHT":
+      return {
+        x: left + sprite.width,
+        y: top + sprite.height,
+        start: Math.PI,
+        end: 3 * Math.PI / 2
+      };
+  }
+}
+function resizeContainer(application, {
+  container,
+  cornerType,
+  position,
+  spriteName
+}) {
+  const sprite = application.stage.getChildByName(spriteName, !0);
+  if (sprite == null) return;
+  const isRotated = sprite.rotation % Math.PI !== 0, spriteWidth = isRotated ? sprite.height : sprite.width, spriteHeight = isRotated ? sprite.width : sprite.height;
+  switch (cornerType) {
+    case "TOP_LEFT": {
+      container.position = new PIXI.Point(position.x, position.y), container.width = spriteWidth - 2 * position.x, container.height = spriteHeight - 2 * position.y;
+      break;
+    }
+    case "TOP_RIGHT": {
+      const newX = spriteWidth - position.x;
+      container.position = new PIXI.Point(newX, position.y), container.width = spriteWidth - 2 * newX, container.height = spriteHeight - 2 * position.y;
+      break;
+    }
+    case "BOTTOM_LEFT": {
+      const newY = spriteHeight - position.y;
+      container.position = new PIXI.Point(position.x, newY), container.width = spriteWidth - 2 * position.x, container.height = spriteHeight - 2 * newY;
+      break;
+    }
+    case "BOTTOM_RIGHT": {
+      const newY = spriteHeight - position.y, newX = spriteWidth - position.x;
+      container.position = new PIXI.Point(newX, newY), container.width = spriteWidth - 2 * newX, container.height = spriteHeight - 2 * newY;
+      break;
+    }
+  }
+}
+function removeCorner(application, cornerType) {
+  const previous = application.stage.getChildByName(getCornerName(cornerType), !0);
+  previous == null || previous.removeFromParent();
+}
+function drawCorner(application, cornerType, {
+  spriteName
+}) {
+  removeCorner(application, cornerType);
+  const sprite = application.stage.getChildByName(spriteName, !0), container = application.stage.getChildByName(CONTROL_NAME, !0);
+  if (sprite == null || container === null || container === void 0) return;
+  const position = computeCornerPosition(cornerType, container), corner = new PIXI.Graphics();
+  corner.beginFill(4960213, 1), corner.arc(0, 0, POINT_RADIUS, position.start, position.end), corner.lineTo(0, 0), corner.endFill(), corner.position = new PIXI.Point(position.x, position.y), corner.name = getCornerName(cornerType), corner.interactive = !0;
+  let enable = !1;
+  application.stage.on("pointermove", (event) => {
+    if (enable === !1) return;
+    const localPosition = application.stage.toLocal(event.global);
+    resizeContainer(application, {
+      cornerType,
+      position: localPosition,
+      container,
+      spriteName
+    });
+  });
+  const handlePointerUp = () => {
+    enable = !1;
+  };
+  globalThis.addEventListener("pointerup", handlePointerUp), corner.once("destroyed", () => {
+    corner.off("pointerdown"), globalThis.removeEventListener("pointerup", handlePointerUp);
+  });
+  const handlePointerDown = () => {
+    enable = !0;
+  };
+  corner.on("pointerdown", handlePointerDown), container.addChild(corner);
+}
+function drawContainer(application, spriteName) {
+  removeContainer(application);
+  const sprite = application.stage.getChildByName(spriteName, !0);
+  if (sprite == null) return;
+  const stageTexture = application.renderer.generateTexture(application.stage), clonedStage = new PIXI.Sprite(stageTexture);
+  application.stage.children.forEach((child) => {
+    child.alpha = 0;
+  });
+  const container = new PIXI.Graphics();
+  container.drawRect(0, 0, sprite.width, sprite.height), container.name = CONTROL_NAME, container.interactive = !0, container.interactiveChildren = !0, application.stage.interactive = !0, application.stage.interactiveChildren = !0, application.stage.addChild(container), container.addChild(clonedStage);
+}
+function removeContainer(application) {
+  const container = application.stage.getChildByName(CONTROL_NAME, !0);
+  container == null || container.removeFromParent(), application.stage.children.forEach((child) => {
+    child.alpha = 1;
+  });
+}
+function drawControl(application, spriteName) {
+  drawContainer(application, spriteName), drawCorner(application, "BOTTOM_LEFT", {
+    spriteName
+  }), drawCorner(application, "BOTTOM_RIGHT", {
+    spriteName
+  }), drawCorner(application, "TOP_LEFT", {
+    spriteName
+  }), drawCorner(application, "TOP_RIGHT", {
+    spriteName
+  });
+}
+function removeControl(application) {
+  removeContainer(application), removeCorner(application, "BOTTOM_LEFT"), removeCorner(application, "BOTTOM_RIGHT"), removeCorner(application, "TOP_LEFT"), removeCorner(application, "TOP_RIGHT"), application.stage.off("pointermove");
+}
+function start(application, spriteName) {
+  drawControl(application, spriteName);
+}
+function stop(application) {
+  removeControl(application), application.stage.off("pointermove"), application.render();
+}
+function save(application) {
+  var _a;
+  const container = (_a = application == null ? void 0 : application.stage) == null ? void 0 : _a.getChildByName(CONTROL_NAME, !0), size = container ? {
+    height: container.height,
+    width: container.width
+  } : void 0;
+  if (removeControl(application), size) {
+    const stageTexture = application.renderer.generateTexture(application.stage).clone(), clonedStage = new PIXI.Sprite(stageTexture);
+    return clonedStage.width = size.width, clonedStage.height = size.height, clonedStage;
+  } else
+    return;
+}
+export {
+  save,
+  start,
+  stop
+};

package/dist/modules/multimedia/ImageEditor/effects/rotate.d.ts

@@ -0,0 +1,8 @@
+import * as PIXI from 'pixi.js';
+/**
+ * This function rotate the sprite by adding PI/2
+ *
+ * @param application The PIXI.Application context
+ * @param spriteName The name of the sprite representing the image
+ */
+export declare function rotate(application: PIXI.Application, spriteName: string): Promise<void>;