@node-projects/web-component-designer 0.0.292 → 0.1.0

package/dist/elements/helper/Screenshot.d.ts

@@ -1,11 +0,0 @@
-export declare class Screenshot {
-    private static _canvas;
-    private static _context;
-    private static _video;
-    private static _captureStream;
-    private static _disableStream;
-    static get screenshotsEnabled(): boolean;
-    static enableScreenshots(elementHostForVideo?: Element): Promise<void>;
-    static takeScreenshot(element: Element, width?: number, height?: number, elementHostForVideo?: Element): Promise<string>;
-    private static _sleep;
-}

package/dist/elements/helper/Screenshot.js

@@ -1,60 +0,0 @@
-// for screenshots to be genrated properly, you need to select the current tab only in media source selector
-export class Screenshot {
-    static _canvas;
-    static _context;
-    static _video;
-    static _captureStream;
-    static _disableStream() {
-        Screenshot._captureStream.getTracks().forEach(track => track.stop());
-        Screenshot._canvas = null;
-    }
-    static get screenshotsEnabled() {
-        return Screenshot._captureStream && Screenshot._captureStream.active;
-    }
-    static async enableScreenshots(elementHostForVideo = document.body) {
-        if (Screenshot._captureStream && !Screenshot._captureStream.active) {
-            Screenshot._disableStream();
-        }
-        if (Screenshot._canvas == null) {
-            Screenshot._canvas = document.createElement("canvas");
-            Screenshot._context = Screenshot._canvas.getContext("2d");
-            Screenshot._video = document.createElement("video");
-            const gdmOptions = {
-                video: {
-                    cursor: "never",
-                    displaySurface: 'browser'
-                },
-                audio: false
-            };
-            Screenshot._video.style.display = "none";
-            elementHostForVideo.appendChild(Screenshot._video);
-            //@ts-ignore
-            Screenshot._captureStream = await navigator.mediaDevices.getDisplayMedia(gdmOptions);
-            //@ts-ignore
-            const captureType = Screenshot._captureStream.getVideoTracks()[0].getSettings().displaySurface;
-            if (captureType != 'browser') {
-                Screenshot._disableStream();
-                alert('You need to share the current Tab, for the screenshot API to work');
-                throw 'You need to share the current Tab, for the screenshot API to work';
-            }
-            Screenshot._video.srcObject = Screenshot._captureStream;
-            Screenshot._video.play();
-            await Screenshot._sleep(150);
-        }
-    }
-    static async takeScreenshot(element, width = 100, height = 100, elementHostForVideo = document.body) {
-        await Screenshot.enableScreenshots(elementHostForVideo);
-        const rect = element.getBoundingClientRect();
-        Screenshot._canvas.width = width;
-        Screenshot._canvas.height = height;
-        Screenshot._context.drawImage(Screenshot._video, rect.left, rect.top, rect.width, rect.height, 0, 0, width, height);
-        const frame = Screenshot._canvas.toDataURL("image/png");
-        return frame;
-    }
-    static _sleep(timeout) {
-        let resolve = null;
-        const promise = new Promise(r => resolve = r);
-        window.setTimeout(resolve, timeout);
-        return promise;
-    }
-}

package/dist/elements/helper/SimpleTextWriter.d.ts

@@ -1,13 +0,0 @@
-import { ITextWriter } from './ITextWriter.js';
-export declare class SimpleTextWriter implements ITextWriter {
-    private _textHolder;
-    get position(): number;
-    isLastCharNewline(): boolean;
-    levelRaise(): void;
-    levelShrink(): void;
-    write(text: string): void;
-    writeLine(text: string): void;
-    writeIndent(): void;
-    writeNewline(): void;
-    getString(): string;
-}

package/dist/elements/helper/SimpleTextWriter.js

@@ -1,26 +0,0 @@
-export class SimpleTextWriter {
-    _textHolder = '';
-    get position() {
-        return this._textHolder.length;
-    }
-    isLastCharNewline() {
-        return this._textHolder[this._textHolder.length - 1] === '\n';
-    }
-    levelRaise() {
-    }
-    levelShrink() {
-    }
-    write(text) {
-        this._textHolder += text;
-    }
-    writeLine(text) {
-        this._textHolder += text;
-    }
-    writeIndent() {
-    }
-    writeNewline() {
-    }
-    getString() {
-        return this._textHolder;
-    }
-}

package/dist/elements/helper/SvgHelper.d.ts

@@ -1 +0,0 @@
-export declare function isVisualSvgElement(element: SVGElement): boolean;

package/dist/elements/helper/SvgHelper.js

@@ -1,13 +0,0 @@
-export function isVisualSvgElement(element) {
-    let el = element;
-    while (el) {
-        if (el instanceof SVGSVGElement)
-            return true;
-        if (el instanceof SVGDefsElement)
-            return false;
-        if (el instanceof SVGMetadataElement)
-            return false;
-        el = el.parentElement;
-    }
-    return true;
-}

package/dist/elements/helper/SwitchContainerHelper.d.ts

@@ -1,2 +0,0 @@
-import { IDesignItem } from '../item/IDesignItem.js';
-export declare function switchContainer(items: IDesignItem[], newContainer: IDesignItem, resizeNewContainer?: boolean, newContainerOffset?: number): void;

package/dist/elements/helper/SwitchContainerHelper.js

@@ -1,45 +0,0 @@
-export function switchContainer(items, newContainer, resizeNewContainer = false, newContainerOffset = 0) {
-    //todo...
-    //- switch to other containers? like grid, flexbox, ...
-    //- position non absolute, or absolute from bottom or right
-    const firstItem = items[0];
-    const grp = firstItem.openGroup('switchContainerHelper');
-    const designerCanvas = firstItem.instanceServiceContainer.designerCanvas;
-    let minX = Number.MAX_VALUE;
-    let minY = Number.MAX_VALUE;
-    let maxX = 0;
-    let maxY = 0;
-    for (let e of items) {
-        let rect = designerCanvas.getNormalizedElementCoordinates(e.element);
-        if (rect.x < minX)
-            minX = rect.x;
-        if (rect.y < minY)
-            minY = rect.y;
-        if (rect.x + rect.width > maxX)
-            maxX = rect.x + rect.width;
-        if (rect.y + rect.height > maxY)
-            maxY = rect.y + rect.height;
-    }
-    let rectNewContainer = designerCanvas.getNormalizedElementCoordinates(newContainer.element);
-    for (let e of items) {
-        let rect = designerCanvas.getNormalizedElementCoordinates(e.element);
-        e.remove();
-        if (resizeNewContainer) {
-            e.setStyle('left', (rect.x - minX + newContainerOffset).toString() + 'px');
-            e.setStyle('top', (rect.y - minY + newContainerOffset).toString() + 'px');
-        }
-        else {
-            e.setStyle('left', (rect.x - rectNewContainer.x).toString() + 'px');
-            e.setStyle('top', (rect.y - rectNewContainer.y).toString() + 'px');
-        }
-        newContainer.insertChild(e);
-    }
-    if (resizeNewContainer) {
-        newContainer.setStyle('position', 'absolute');
-        newContainer.setStyle('left', (minX - newContainerOffset).toString() + 'px');
-        newContainer.setStyle('top', (minY - newContainerOffset).toString() + 'px');
-        newContainer.setStyle('width', (maxX - minX + 2 * newContainerOffset).toString() + 'px');
-        newContainer.setStyle('height', (maxY - minY + 2 * newContainerOffset).toString() + 'px');
-    }
-    grp.commit();
-}

package/dist/elements/helper/TextHelper.d.ts

@@ -1,10 +0,0 @@
-/**
-  * Uses canvas.measureText to compute and return the width of the given text of given font in pixels.
-  *
-  * @param {String} text The text to be rendered.
-  * @param {String} font The css font descriptor that text is to be rendered with (e.g. "bold 14px verdana").
-  *
-  * @see https://stackoverflow.com/questions/118241/calculate-text-width-with-javascript/21015393#21015393
-  */
-export declare function getTextWidth(text: string, font: string): number;
-export declare function getFont(el: Element): string;

package/dist/elements/helper/TextHelper.js

@@ -1,23 +0,0 @@
-let canvas;
-/**
-  * Uses canvas.measureText to compute and return the width of the given text of given font in pixels.
-  *
-  * @param {String} text The text to be rendered.
-  * @param {String} font The css font descriptor that text is to be rendered with (e.g. "bold 14px verdana").
-  *
-  * @see https://stackoverflow.com/questions/118241/calculate-text-width-with-javascript/21015393#21015393
-  */
-export function getTextWidth(text, font) {
-    if (!canvas)
-        canvas = document.createElement("canvas");
-    const context = canvas.getContext("2d");
-    context.font = font;
-    const metrics = context.measureText(text);
-    return metrics.width;
-}
-export function getFont(el) {
-    const fontWeight = getComputedStyle(el).fontWeight || 'normal';
-    const fontSize = getComputedStyle(el).fontSize || '16px';
-    const fontFamily = getComputedStyle(el).fontFamily || 'Times New Roman';
-    return `${fontWeight} ${fontSize} ${fontFamily}`;
-}

package/dist/elements/helper/TransformHelper.d.ts

@@ -1,23 +0,0 @@
-import { IPoint } from "../../interfaces/IPoint.js";
-import { IDesignerCanvas } from "../widgets/designerView/IDesignerCanvas.js";
-export declare function getElementCombinedTransform(element: HTMLElement): DOMMatrix;
-export declare function combineTransforms(element: HTMLElement, actualTransforms: string, requestedTransformation: string): void;
-export declare function transformPointByInverseMatrix(point: DOMPoint, matrix: DOMMatrix): DOMPoint;
-export declare function getRotationMatrix3d(axisOfRotation: 'x' | 'y' | 'z' | 'X' | 'Y' | 'Z', angle: number): any[];
-export declare function rotateElementByMatrix3d(element: HTMLElement, matrix: number[]): void;
-export declare function matrixArrayToCssMatrix(matrixArray: number[]): string;
-export declare function cssMatrixToMatrixArray(cssMatrix: string): number[];
-export declare function getRotationAngleFromMatrix(matrixArray: number[], domMatrix: DOMMatrix): any;
-export declare function addVectors(vectorA: [number, number], vectorB: [number, number]): [number, number];
-export declare function getDesignerCanvasNormalizedTransformedOriginWithoutParentTransformation(element: HTMLElement, designerCanvas: IDesignerCanvas): DOMPoint;
-export declare function getResultingTransformationBetweenElementAndAllAncestors(element: HTMLElement, ancestor: HTMLElement, excludeAncestor?: boolean): DOMMatrix;
-export declare function getByParentsTransformedPointRelatedToCanvas(element: HTMLElement, point: DOMPoint, designerCanvas: IDesignerCanvas): IPoint;
-export declare function getDesignerCanvasNormalizedTransformedPoint(element: HTMLElement, point: IPoint, designerCanvas: IDesignerCanvas): IPoint;
-export declare function getElementSize(element: HTMLElement): {
-    width: number;
-    height: number;
-};
-export declare function getDesignerCanvasNormalizedTransformedCornerDOMPoints(element: HTMLElement, untransformedCornerPointsOffset: IPoint | null, designerCanvas: IDesignerCanvas): [DOMPoint, DOMPoint, DOMPoint, DOMPoint];
-export declare function extractTranslationFromDOMMatrix(matrix: DOMMatrix): DOMPoint;
-export declare function extractRotationAngleFromDOMMatrix(matrix: DOMMatrix): number;
-export declare function normalizeToAbsolutePosition(element: HTMLElement, normalizeProperty: "left" | "top"): string;

package/dist/elements/helper/TransformHelper.js

@@ -1,239 +0,0 @@
-import { getElementsWindowOffsetWithoutSelfAndParentTransformations, getParentElementIncludingSlots } from "./ElementHelper.js";
-let identityMatrix = [
-    1, 0, 0, 0,
-    0, 1, 0, 0,
-    0, 0, 1, 0,
-    0, 0, 0, 1
-];
-export function getElementCombinedTransform(element) {
-    //https://www.w3.org/TR/css-transforms-2/#ctm
-    let s = getComputedStyle(element);
-    let m = new DOMMatrix();
-    if (s.translate != 'none') {
-        m = m.multiply(new DOMMatrix('translate(' + s.translate + ')'));
-    }
-    if (s.rotate != 'none') {
-        m = m.multiply(new DOMMatrix('rotate(' + s.rotate + ')'));
-    }
-    if (s.scale != 'none') {
-        m = m.multiply(new DOMMatrix('scale(' + s.rotate + ')'));
-    }
-    if (s.transform != 'none') {
-        m = m.multiply(new DOMMatrix(s.transform));
-    }
-    return m;
-}
-export function combineTransforms(element, actualTransforms, requestedTransformation) {
-    if (actualTransforms == null || actualTransforms == '') {
-        element.style.transform = requestedTransformation;
-        return;
-    }
-    const actualTransformationMatrix = new DOMMatrix(actualTransforms);
-    const requestedTransformationMatrix = new DOMMatrix(requestedTransformation);
-    const newTransformationMatrix = requestedTransformationMatrix.multiply(actualTransformationMatrix);
-    element.style.transform = newTransformationMatrix.toString();
-}
-export function transformPointByInverseMatrix(point, matrix) {
-    const inverse = matrix.inverse();
-    //fix chrome bug: https://bugs.chromium.org/p/chromium/issues/detail?id=1395645
-    inverse.m33 = 1;
-    inverse.m44 = 1;
-    return point.matrixTransform(inverse);
-}
-export function getRotationMatrix3d(axisOfRotation, angle) {
-    const angleInRadians = angle / 180 * Math.PI;
-    const sin = Math.sin;
-    const cos = Math.cos;
-    let rotationMatrix3d = [];
-    switch (axisOfRotation.toLowerCase()) {
-        case 'x':
-            rotationMatrix3d = [
-                1, 0, 0, 0,
-                0, cos(angleInRadians), -sin(angleInRadians), 0,
-                0, sin(angleInRadians), cos(angleInRadians), 0,
-                0, 0, 0, 1
-            ];
-            break;
-        case 'y':
-            rotationMatrix3d = [
-                cos(angleInRadians), 0, sin(angleInRadians), 0,
-                0, 1, 0, 0,
-                -sin(angleInRadians), 0, cos(angleInRadians), 0,
-                0, 0, 0, 1
-            ];
-            break;
-        case 'z':
-            rotationMatrix3d = [
-                cos(angleInRadians), -sin(angleInRadians), 0, 0,
-                sin(angleInRadians), cos(angleInRadians), 0, 0,
-                0, 0, 1, 0,
-                0, 0, 0, 1
-            ];
-            break;
-        default:
-            rotationMatrix3d = null;
-            break;
-    }
-    return rotationMatrix3d;
-}
-export function rotateElementByMatrix3d(element, matrix) {
-    element.style.transform = matrixArrayToCssMatrix(matrix);
-}
-export function matrixArrayToCssMatrix(matrixArray) {
-    return "matrix3d(" + matrixArray.join(',') + ")";
-}
-export function cssMatrixToMatrixArray(cssMatrix) {
-    if (!cssMatrix.includes('matrix')) {
-        if (cssMatrix != 'none')
-            console.error('cssMatrixToMatrixArray: no css matrix passed');
-        return identityMatrix;
-    }
-    let matrixArray = cssMatrix.match(/^matrix.*\((.*)\)/)[1].split(',').map(Number);
-    return matrixArray;
-}
-export function getRotationAngleFromMatrix(matrixArray, domMatrix) {
-    let angle = null;
-    const a = domMatrix != null ? domMatrix.a : matrixArray[0];
-    const b = domMatrix != null ? domMatrix.b : matrixArray[1];
-    angle = Math.round(Math.atan2(b, a) * (180 / Math.PI));
-    return angle;
-}
-export function addVectors(vectorA, vectorB) {
-    return [vectorA[0] + vectorB[0], vectorA[1] + vectorB[1]];
-}
-export function getDesignerCanvasNormalizedTransformedOriginWithoutParentTransformation(element, designerCanvas) {
-    const top0 = new DOMPointReadOnly(-parseFloat(getComputedStyle(element).transformOrigin.split(' ')[0]), -parseFloat(getComputedStyle(element).transformOrigin.split(' ')[1]), 0, 0);
-    const p0Offsets = getElementsWindowOffsetWithoutSelfAndParentTransformations(element, designerCanvas.zoomFactor);
-    const transformOriginAbsolutRelatedToWindowWithoutAnyTransformation = new DOMPoint(p0Offsets.offsetLeft - top0.x, p0Offsets.offsetTop - top0.y);
-    const designerCanvasNormalizedTransformedOrigin = new DOMPoint(transformOriginAbsolutRelatedToWindowWithoutAnyTransformation.x - designerCanvas.containerBoundingRect.x, transformOriginAbsolutRelatedToWindowWithoutAnyTransformation.y - designerCanvas.containerBoundingRect.y);
-    return designerCanvasNormalizedTransformedOrigin;
-}
-export function getResultingTransformationBetweenElementAndAllAncestors(element, ancestor, excludeAncestor) {
-    let actualElement = element;
-    let actualElementMatrix;
-    let newElementMatrix;
-    let originalElementAndAllParentsMultipliedMatrix;
-    while (actualElement != ancestor) {
-        const newElement = getParentElementIncludingSlots(actualElement);
-        actualElementMatrix = getElementCombinedTransform(actualElement);
-        newElementMatrix = getElementCombinedTransform(newElement);
-        newElementMatrix.m41 = newElementMatrix.m42 = 0;
-        if (actualElement == element) {
-            originalElementAndAllParentsMultipliedMatrix = actualElementMatrix.multiply(newElementMatrix);
-        }
-        else if (newElement != ancestor || !excludeAncestor) {
-            originalElementAndAllParentsMultipliedMatrix = originalElementAndAllParentsMultipliedMatrix.multiply(newElementMatrix);
-        }
-        actualElement = newElement;
-    }
-    return originalElementAndAllParentsMultipliedMatrix;
-}
-export function getByParentsTransformedPointRelatedToCanvas(element, point, designerCanvas) {
-    const canvas = element.closest('#node-projects-designer-canvas-canvas');
-    let actualElement = element;
-    let parentElementTransformOriginToPointVectorTransformed;
-    let byParentTransformedPointRelatedToCanvas = { x: 0, y: 0 };
-    while (actualElement != canvas) {
-        const parentElement = getParentElementIncludingSlots(actualElement);
-        const parentElementTransformOrigin = new DOMPoint(getElementsWindowOffsetWithoutSelfAndParentTransformations(parentElement, designerCanvas.zoomFactor).offsetLeft - designerCanvas.outerRect.x + parseFloat(getComputedStyle(parentElement).transformOrigin.split(' ')[0]), getElementsWindowOffsetWithoutSelfAndParentTransformations(parentElement, designerCanvas.zoomFactor).offsetTop - designerCanvas.outerRect.y + parseFloat(getComputedStyle(parentElement).transformOrigin.split(' ')[1]));
-        if (actualElement == element) {
-            parentElementTransformOrigin.x -= extractTranslationFromDOMMatrix(new DOMMatrix(element.style.transform)).x;
-            parentElementTransformOrigin.y -= extractTranslationFromDOMMatrix(new DOMMatrix(element.style.transform)).y;
-        }
-        const parentElementTransformOriginToPointVector = new DOMPointReadOnly(-parentElementTransformOrigin.x + (element == actualElement ? point.x : byParentTransformedPointRelatedToCanvas.x), -parentElementTransformOrigin.y + (element == actualElement ? point.y : byParentTransformedPointRelatedToCanvas.y));
-        parentElementTransformOriginToPointVectorTransformed = parentElementTransformOriginToPointVector.matrixTransform(new DOMMatrix(getComputedStyle(parentElement).transform));
-        byParentTransformedPointRelatedToCanvas = new DOMPoint(parentElementTransformOrigin.x + parentElementTransformOriginToPointVectorTransformed.x, parentElementTransformOrigin.y + parentElementTransformOriginToPointVectorTransformed.y);
-        actualElement = parentElement;
-    }
-    return byParentTransformedPointRelatedToCanvas;
-}
-export function getDesignerCanvasNormalizedTransformedPoint(element, point, designerCanvas) {
-    return getDesignerCanvasNormalizedTransformedCornerDOMPoints(element, { x: -point.x, y: -point.y }, designerCanvas)[0];
-}
-export function getElementSize(element) {
-    let width = element.offsetWidth;
-    let height = element.offsetHeight;
-    if (element instanceof SVGElement && element.width) {
-        width = element.width.baseVal.value;
-        height = element.height.baseVal.value;
-    }
-    else if (element instanceof SVGGraphicsElement) {
-        let bbox = element.getBBox();
-        width = bbox.width;
-        height = bbox.height;
-    }
-    return { width, height };
-}
-export function getDesignerCanvasNormalizedTransformedCornerDOMPoints(element, untransformedCornerPointsOffset, designerCanvas) {
-    const topleft = 0;
-    const topright = 1;
-    const bottomleft = 2;
-    const bottomright = 3;
-    const intUntransformedCornerPointsOffset = untransformedCornerPointsOffset ? { x: untransformedCornerPointsOffset.x / designerCanvas.scaleFactor, y: untransformedCornerPointsOffset.y / designerCanvas.scaleFactor } : { x: 0, y: 0 };
-    const p0Offsets = getElementsWindowOffsetWithoutSelfAndParentTransformations(element, designerCanvas.zoomFactor);
-    const p0OffsetsRelatedToCanvas = DOMPoint.fromPoint({
-        x: p0Offsets.offsetLeft - designerCanvas.containerBoundingRect.left,
-        y: p0Offsets.offsetTop - designerCanvas.containerBoundingRect.top
-    });
-    let { width, height } = getElementSize(element);
-    const elementWithoutTransformCornerDOMPoints = [];
-    elementWithoutTransformCornerDOMPoints[topleft] = DOMPoint.fromPoint({
-        x: p0OffsetsRelatedToCanvas.x - intUntransformedCornerPointsOffset.x,
-        y: p0OffsetsRelatedToCanvas.y - intUntransformedCornerPointsOffset.y
-    });
-    elementWithoutTransformCornerDOMPoints[topright] = DOMPoint.fromPoint({
-        x: p0OffsetsRelatedToCanvas.x + width + intUntransformedCornerPointsOffset.x,
-        y: p0OffsetsRelatedToCanvas.y - intUntransformedCornerPointsOffset.y
-    });
-    elementWithoutTransformCornerDOMPoints[bottomleft] = DOMPoint.fromPoint({
-        x: p0OffsetsRelatedToCanvas.x - intUntransformedCornerPointsOffset.x,
-        y: p0OffsetsRelatedToCanvas.y + height + intUntransformedCornerPointsOffset.y
-    });
-    elementWithoutTransformCornerDOMPoints[bottomright] = DOMPoint.fromPoint({
-        x: p0OffsetsRelatedToCanvas.x + width + intUntransformedCornerPointsOffset.x,
-        y: p0OffsetsRelatedToCanvas.y + height + intUntransformedCornerPointsOffset.y
-    });
-    const transformOriginWithoutTransformRelatedToCanvas = DOMPointReadOnly.fromPoint({
-        x: p0OffsetsRelatedToCanvas.x + parseFloat(getComputedStyle(element).transformOrigin.split(' ')[0]),
-        y: p0OffsetsRelatedToCanvas.y + parseFloat(getComputedStyle(element).transformOrigin.split(' ')[1]),
-        z: 0,
-        w: 0
-    });
-    const designerCanvasNormalizedTransformOrigin = getByParentsTransformedPointRelatedToCanvas(element, new DOMPoint(getElementsWindowOffsetWithoutSelfAndParentTransformations(element, designerCanvas.zoomFactor).offsetLeft - designerCanvas.outerRect.left + parseFloat(getComputedStyle(element).transformOrigin.split(' ')[0]), getElementsWindowOffsetWithoutSelfAndParentTransformations(element, designerCanvas.zoomFactor).offsetTop - designerCanvas.outerRect.top + parseFloat(getComputedStyle(element).transformOrigin.split(' ')[1])), designerCanvas);
-    let top0 = new DOMPoint(-(transformOriginWithoutTransformRelatedToCanvas.x - elementWithoutTransformCornerDOMPoints[topleft].x), -(transformOriginWithoutTransformRelatedToCanvas.y - elementWithoutTransformCornerDOMPoints[topleft].y));
-    let top1 = new DOMPoint(-(transformOriginWithoutTransformRelatedToCanvas.x - elementWithoutTransformCornerDOMPoints[topright].x), -(transformOriginWithoutTransformRelatedToCanvas.y - elementWithoutTransformCornerDOMPoints[topright].y));
-    let top2 = new DOMPoint(-(transformOriginWithoutTransformRelatedToCanvas.x - elementWithoutTransformCornerDOMPoints[bottomleft].x), -(transformOriginWithoutTransformRelatedToCanvas.y - elementWithoutTransformCornerDOMPoints[bottomleft].y));
-    let top3 = new DOMPoint(-(transformOriginWithoutTransformRelatedToCanvas.x - elementWithoutTransformCornerDOMPoints[bottomright].x), -(transformOriginWithoutTransformRelatedToCanvas.y - elementWithoutTransformCornerDOMPoints[bottomright].y));
-    let originalElementAndAllParentsMultipliedMatrix = getResultingTransformationBetweenElementAndAllAncestors(element, designerCanvas.canvas, true);
-    let top0Transformed = top0.matrixTransform(originalElementAndAllParentsMultipliedMatrix);
-    let top1Transformed = top1.matrixTransform(originalElementAndAllParentsMultipliedMatrix);
-    let top2Transformed = top2.matrixTransform(originalElementAndAllParentsMultipliedMatrix);
-    let top3Transformed = top3.matrixTransform(originalElementAndAllParentsMultipliedMatrix);
-    let transformedCornerPoints = [];
-    transformedCornerPoints[0] = new DOMPoint(designerCanvasNormalizedTransformOrigin.x + top0Transformed.x, designerCanvasNormalizedTransformOrigin.y + top0Transformed.y);
-    transformedCornerPoints[1] = new DOMPoint(designerCanvasNormalizedTransformOrigin.x + top1Transformed.x, designerCanvasNormalizedTransformOrigin.y + top1Transformed.y);
-    transformedCornerPoints[2] = new DOMPoint(designerCanvasNormalizedTransformOrigin.x + top2Transformed.x, designerCanvasNormalizedTransformOrigin.y + top2Transformed.y);
-    transformedCornerPoints[3] = new DOMPoint(designerCanvasNormalizedTransformOrigin.x + top3Transformed.x, designerCanvasNormalizedTransformOrigin.y + top3Transformed.y);
-    return transformedCornerPoints;
-}
-export function extractTranslationFromDOMMatrix(matrix) {
-    return new DOMPoint(matrix.m41, matrix.m42, 0, 0);
-}
-export function extractRotationAngleFromDOMMatrix(matrix) {
-    return getRotationAngleFromMatrix(null, matrix);
-}
-export function normalizeToAbsolutePosition(element, normalizeProperty) {
-    switch (normalizeProperty) {
-        case "left":
-            let left = getComputedStyle(element).left;
-            element.style.removeProperty('right');
-            element.style.left = left;
-            return left;
-        case "top":
-            let top = getComputedStyle(element).top;
-            element.style.removeProperty('bottom');
-            element.style.top = top;
-            return top;
-    }
-    return null;
-}

package/dist/elements/helper/XmlHelper.d.ts

@@ -1,2 +0,0 @@
-export declare function encodeXMLChars(value: string): string;
-export declare function decodeXMLChars(value: string): string;

package/dist/elements/helper/XmlHelper.js

@@ -1,16 +0,0 @@
-export function encodeXMLChars(value) {
-    return value.replace(/&/g, '&')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&apos;');
-}
-;
-export function decodeXMLChars(value) {
-    return value.replace(/&apos;/g, "'")
-        .replace(/&quot;/g, '"')
-        .replace(/&gt;/g, '>')
-        .replace(/&lt;/g, '<')
-        .replace(/&amp;/g, '&');
-}
-;

package/dist/elements/helper/contextMenu/ContextMenu.d.ts

@@ -1,26 +0,0 @@
-import { IContextMenu, IContextMenuItem } from './IContextMenuItem.js';
-export interface IContextMenuOptions {
-    defaultIcon?: string;
-    subIcon?: string;
-    mouseOffset?: number;
-    shadowRoot?: ShadowRoot | Document;
-    mode?: 'normal' | 'undo';
-}
-export declare class ContextMenu implements IContextMenu {
-    private static _contextMenuCss;
-    static count: number;
-    menu: IContextMenuItem[];
-    options: IContextMenuOptions;
-    context: any;
-    private num;
-    private _menuElement;
-    constructor(menu: IContextMenuItem[], options?: IContextMenuOptions, context?: any);
-    reload(): void;
-    renderLevel(level: IContextMenuItem[]): HTMLUListElement;
-    display(event: MouseEvent): void;
-    _windowResize(): void;
-    _windowDown(e: MouseEvent): boolean;
-    _windowKeyUp(e: KeyboardEvent): void;
-    static show(menu: IContextMenuItem[], event: MouseEvent, options?: IContextMenuOptions, context?: any): ContextMenu;
-    close(): void;
-}