@alauda-fe/common 1.0.0-next.0

package/esm2022/mutable/mutable.directive.mjs

@@ -0,0 +1,356 @@
+import { ContentChildren, Directive, ElementRef, EventEmitter, HostListener, Input, Output, QueryList, } from '@angular/core';
+import { coerceElement, isSelfOrParent } from './element';
+import { isL, isT, toNumber, toPx } from './util';
+import * as i0 from "@angular/core";
+export const MUTABLE_BASIC_OPTIONS = {
+    directions: [true, true, true, true],
+    resizeThreshold: 5,
+    cursors: {
+        move: 'move',
+    },
+};
+export class DragHandleDirective {
+    static { this.ɵfac = function DragHandleDirective_Factory(t) { return new (t || DragHandleDirective)(); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: DragHandleDirective, selectors: [["", "aclDragHandle", ""]] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DragHandleDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclDragHandle]',
+            }]
+    }], null, null); })();
+export class MutableDirective {
+    set aclMutableOptions(options) {
+        this.computedOptions = {
+            ...MUTABLE_BASIC_OPTIONS,
+            ...options,
+        };
+    }
+    onMouseDown(event) {
+        if (!isSelfOrParent(event.target, this.element)) {
+            return;
+        }
+        const cursor = this.getMutableCursor(event);
+        if (cursor === this.computedOptions.cursors.move) {
+            this.setDragging(cursor, event);
+            this.aclDragStarted.emit(this.element);
+        }
+        else if (this.aclResizable && cursor.includes('-resize')) {
+            this.setResizing(cursor, event);
+            this.aclResizeStarted.emit(this.element);
+        }
+    }
+    onMouseMove(event) {
+        this.element.style.cursor = this.getMutableCursor(event);
+        if (this.isDragging) {
+            this.dragElement(event);
+            this.aclOnDrag.emit(this.element);
+        }
+        if (this.isResizingX || this.isResizingY) {
+            this.isResizingX && this.resizeElementX(event);
+            this.isResizingY && this.resizeElementY(event);
+            this.aclOnResize.emit(this.element);
+        }
+    }
+    onMouseUp() {
+        if (this.aclDraggable) {
+            this.setDragging(null, null);
+            this.aclDragEnded.emit(this.element);
+        }
+        if (this.aclResizable) {
+            this.setResizing(null, null);
+            this.aclResizeEnded.emit(this.element);
+        }
+    }
+    constructor(el) {
+        this.el = el;
+        this.computedOptions = MUTABLE_BASIC_OPTIONS;
+        /** Allow for stretch shrink, the default is open */
+        this.aclResizable = true;
+        /** Allow for drag and drop, the default is open */
+        this.aclDraggable = true;
+        /** In the process of the resize triggering events */
+        this.aclOnResize = new EventEmitter();
+        /** Drag in the process of the triggering event */
+        this.aclOnDrag = new EventEmitter();
+        /** Emits when the user start drag. */
+        this.aclDragStarted = new EventEmitter();
+        this.aclDragEnded = new EventEmitter();
+        /** Emits when the user start resize */
+        this.aclResizeStarted = new EventEmitter();
+        this.aclResizeEnded = new EventEmitter();
+        this.isDragging = false;
+        this.isResizingX = false;
+        this.isResizingY = false;
+        this.mousePoint = { x: 0, y: 0 };
+        this.element = null;
+        this.resizeInitXRight = 0;
+        this.resizeInitYBottom = 0;
+        this.element = this.el.nativeElement;
+        this._initCursor = this.element.style.cursor;
+    }
+    /** Gets the boundary element, based on the `boundaryElement` value. */
+    getBoundaryElement() {
+        const boundary = this.aclDragBoundary;
+        if (!boundary) {
+            return this.element.parentNode;
+        }
+        if (typeof boundary === 'string') {
+            return this.element.closest(boundary);
+        }
+        return coerceElement(boundary);
+    }
+    ensureInParent(point) {
+        const parent = this.getBoundaryElement();
+        const elementRect = this.element.getBoundingClientRect();
+        if (point.x < 0) {
+            point.x = 0;
+        }
+        else if (point.x >= parent.clientWidth - elementRect.width) {
+            point.x = parent.clientWidth - elementRect.width;
+        }
+        if (point.y < 0) {
+            point.y = 0;
+        }
+        else if (point.y >= parent.clientHeight - elementRect.height) {
+            point.y = parent.clientHeight - elementRect.height;
+        }
+        return point;
+    }
+    dragElement(event) {
+        const parentElement = this.getBoundaryElement();
+        const parentRect = {
+            left: parentElement.getBoundingClientRect().left + parentElement.scrollLeft,
+            top: parentElement.getBoundingClientRect().top + parentElement.scrollTop,
+        };
+        const { x, y } = this.ensureInParent({
+            x: event.clientX -
+                parentRect.left -
+                this.parentBorder.left -
+                this.mousePoint.x,
+            y: event.clientY -
+                parentRect.top -
+                this.parentBorder.top -
+                this.mousePoint.y,
+        });
+        if (this.computedOptions.dragRange) {
+            const [t, r, b, l] = this.computedOptions.dragRange.map((key, index) => {
+                if (typeof key === 'number') {
+                    return ((key / 100) *
+                        ([1, 3].includes(index)
+                            ? parentElement.clientWidth
+                            : parentElement.clientHeight));
+                }
+                if (typeof key === 'string' && key.includes('px')) {
+                    return toNumber(key);
+                }
+                console.error('DragRange in mutableOptions is invalid!');
+                return 0;
+            });
+            this.element.style.left = toPx(Math.max(l, Math.min(x, parentElement.clientWidth - r)));
+            this.element.style.top = toPx(Math.max(t, Math.min(y, parentElement.clientHeight - b)));
+            return;
+        }
+        this.element.style.left = toPx(x);
+        this.element.style.top = toPx(y);
+    }
+    initDragging(event) {
+        const rect = this.element.getBoundingClientRect();
+        this.mousePoint.x = event.clientX - rect.left;
+        this.mousePoint.y = event.clientY - rect.top;
+        const { borderLeft, borderTop } = getComputedStyle(this.getBoundaryElement());
+        this.parentBorder = {
+            left: toNumber(borderLeft),
+            top: toNumber(borderTop),
+        };
+    }
+    setDragging(cursor, event) {
+        this.isDragging = cursor === this.computedOptions.cursors.move;
+        if (this.isDragging) {
+            this.initDragging(event);
+        }
+    }
+    resizeElementX(event) {
+        if (this.isResizeOutOfBoundary(event, 'horizontal')) {
+            return;
+        }
+        const elementRect = this.element.getBoundingClientRect();
+        let width;
+        const { minWidth, maxWidth, left } = getComputedStyle(this.element);
+        const computedMinWidth = Math.max(toNumber(minWidth), this.elementBorder.left + this.elementBorder.right);
+        if (isL(this.resizeCursor)) {
+            const targetLeft = event.clientX - this.mousePoint.x;
+            const computedWidth = this.resizeInitXRight - targetLeft;
+            width = Math.max(toNumber(maxWidth)
+                ? Math.min(computedWidth, toNumber(maxWidth))
+                : computedWidth, computedMinWidth);
+            this.element.style.left = toPx(toNumber(left) + elementRect.width - width);
+        }
+        else {
+            const targetRight = event.clientX + this.mousePoint.x;
+            const computedWidth = targetRight - elementRect.left;
+            width = Math.max(toNumber(maxWidth)
+                ? Math.min(computedWidth, toNumber(maxWidth))
+                : computedWidth, computedMinWidth);
+        }
+        if (width < this.elementBorder.left + this.elementBorder.right) {
+            return;
+        }
+        this.element.style.width = toPx(width);
+    }
+    resizeElementY(event) {
+        if (this.isResizeOutOfBoundary(event, 'vertical')) {
+            return;
+        }
+        const elementRect = this.element.getBoundingClientRect();
+        const { minHeight, maxHeight, top } = getComputedStyle(this.element);
+        const computedMinHeight = Math.max(toNumber(minHeight), this.elementBorder.top + this.elementBorder.bottom);
+        let height;
+        if (isT(this.resizeCursor)) {
+            const targetTop = event.clientY - this.mousePoint.y;
+            const computedHeight = this.resizeInitYBottom - targetTop;
+            height = Math.max(toNumber(maxHeight)
+                ? Math.min(computedHeight, toNumber(maxHeight))
+                : computedHeight, computedMinHeight);
+            this.element.style.top = toPx(toNumber(top) + elementRect.height - height);
+        }
+        else {
+            const targetBottom = event.clientY + this.mousePoint.y;
+            const computedHeight = targetBottom - elementRect.top;
+            height = Math.max(toNumber(maxHeight)
+                ? Math.min(computedHeight, toNumber(maxHeight))
+                : computedHeight, computedMinHeight);
+        }
+        if (height < this.elementBorder.top + this.elementBorder.bottom) {
+            return;
+        }
+        this.element.style.height = toPx(height);
+    }
+    initResizing(event) {
+        const elementRect = this.element.getBoundingClientRect();
+        this.resizeInitXRight = elementRect.right;
+        this.resizeInitYBottom = elementRect.bottom;
+        this.mousePoint.x = isL(this.resizeCursor)
+            ? event.clientX - elementRect.left
+            : elementRect.right - event.clientX;
+        this.mousePoint.y = isT(this.resizeCursor)
+            ? event.clientY - elementRect.top
+            : elementRect.bottom - event.clientY;
+        const { borderLeft, borderTop, borderBottom, borderRight } = getComputedStyle(this.element);
+        this.elementBorder = {
+            left: toNumber(borderLeft),
+            top: toNumber(borderTop),
+            bottom: toNumber(borderBottom),
+            right: toNumber(borderRight),
+        };
+    }
+    setResizing(cursor, event) {
+        if (cursor == null || !cursor.includes('-resize')) {
+            this.isResizingX = false;
+            this.isResizingY = false;
+            return;
+        }
+        cursor = cursor.replace('-resize', '');
+        this.isResizingX = cursor.includes('e') || cursor.includes('w');
+        this.isResizingY = cursor.includes('s') || cursor.includes('n');
+        this.initResizing(event);
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    getMutableCursor(event) {
+        if (this.isResizingX || this.isResizingY) {
+            return;
+        }
+        const elementRect = this.element.getBoundingClientRect();
+        const resizeThreshold = this.computedOptions.resizeThreshold;
+        const pt = {
+            x: event.clientX,
+            y: event.clientY,
+        };
+        let cursor = '';
+        const dragThreshold = this.aclResizable ? resizeThreshold : 0;
+        if (this.aclDraggable &&
+            pt.x < elementRect.right - dragThreshold &&
+            pt.x > elementRect.left + dragThreshold &&
+            pt.y < elementRect.bottom - dragThreshold &&
+            pt.y > elementRect.top + dragThreshold &&
+            (!this.handles?.length ||
+                this.handles?.some(h => isSelfOrParent(event.target, h.nativeElement)))) {
+            cursor = this.computedOptions.cursors.move;
+        }
+        if (this.aclResizable && !cursor) {
+            if (pt.y >= elementRect.top &&
+                pt.y <= elementRect.top + resizeThreshold) {
+                cursor += 'n';
+            }
+            else if (pt.y >= elementRect.bottom - resizeThreshold &&
+                pt.y <= elementRect.bottom) {
+                cursor += 's';
+            }
+            if (pt.x >= elementRect.left &&
+                pt.x <= elementRect.left + resizeThreshold) {
+                cursor += 'w';
+            }
+            else if (pt.x >= elementRect.right - resizeThreshold &&
+                pt.x <= elementRect.right) {
+                cursor += 'e';
+            }
+            cursor = cursor ? cursor + '-resize' : '';
+        }
+        this.resizeCursor = cursor;
+        return cursor || this._initCursor;
+    }
+    isResizeOutOfBoundary(event, direction) {
+        const parentElement = this.getBoundaryElement();
+        const eventProp = direction === 'horizontal' ? 'clientX' : 'clientY';
+        const parentProp = direction === 'horizontal' ? 'clientWidth' : 'clientHeight';
+        return event[eventProp] < 0 || event[eventProp] > parentElement[parentProp];
+    }
+    static { this.ɵfac = function MutableDirective_Factory(t) { return new (t || MutableDirective)(i0.ɵɵdirectiveInject(i0.ElementRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: MutableDirective, selectors: [["", "aclMutable", ""]], contentQueries: function MutableDirective_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
+            i0.ɵɵcontentQuery(dirIndex, DragHandleDirective, 5, ElementRef);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx.handles = _t);
+        } }, hostBindings: function MutableDirective_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵlistener("mousedown", function MutableDirective_mousedown_HostBindingHandler($event) { return ctx.onMouseDown($event); }, false, i0.ɵɵresolveDocument)("mousemove", function MutableDirective_mousemove_HostBindingHandler($event) { return ctx.onMouseMove($event); }, false, i0.ɵɵresolveDocument)("mouseup", function MutableDirective_mouseup_HostBindingHandler() { return ctx.onMouseUp(); }, false, i0.ɵɵresolveDocument);
+        } }, inputs: { aclResizable: "aclResizable", aclDraggable: "aclDraggable", aclDragBoundary: "aclDragBoundary", aclMutableOptions: "aclMutableOptions" }, outputs: { aclOnResize: "aclOnResize", aclOnDrag: "aclOnDrag", aclDragStarted: "aclDragStarted", aclDragEnded: "aclDragEnded", aclResizeStarted: "aclResizeStarted", aclResizeEnded: "aclResizeEnded" } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MutableDirective, [{
+        type: Directive,
+        args: [{
+                selector: '[aclMutable]',
+            }]
+    }], function () { return [{ type: i0.ElementRef }]; }, { aclResizable: [{
+            type: Input
+        }], aclDraggable: [{
+            type: Input
+        }], aclDragBoundary: [{
+            type: Input
+        }], aclMutableOptions: [{
+            type: Input
+        }], aclOnResize: [{
+            type: Output
+        }], aclOnDrag: [{
+            type: Output
+        }], aclDragStarted: [{
+            type: Output
+        }], aclDragEnded: [{
+            type: Output
+        }], aclResizeStarted: [{
+            type: Output
+        }], aclResizeEnded: [{
+            type: Output
+        }], handles: [{
+            type: ContentChildren,
+            args: [DragHandleDirective, { read: ElementRef, descendants: true }]
+        }], onMouseDown: [{
+            type: HostListener,
+            args: ['document:mousedown', ['$event']]
+        }], onMouseMove: [{
+            type: HostListener,
+            args: ['document:mousemove', ['$event']]
+        }], onMouseUp: [{
+            type: HostListener,
+            args: ['document:mouseup']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mutable.directive.js","sourceRoot":"","sources":["../../../../../libs/common/src/mutable/mutable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostListener,\n  Input,\n  Output,\n  QueryList,\n} from '@angular/core';\n\nimport { coerceElement, isSelfOrParent } from './element';\nimport { ResizeCursor, isL, isT, toNumber, toPx } from './util';\n\nexport type DragRange = number | string;\nexport interface MutableOptions {\n  directions?: [boolean, boolean, boolean, boolean]; // top right bottom left;\n  resizeThreshold?: number;\n  cursors?: {\n    move: string;\n  };\n  dragRange?: [DragRange, DragRange, DragRange, DragRange];\n}\n\nexport const MUTABLE_BASIC_OPTIONS: MutableOptions = {\n  directions: [true, true, true, true],\n  resizeThreshold: 5,\n  cursors: {\n    move: 'move',\n  },\n};\n\nexport interface Point {\n  x: number;\n  y: number;\n}\n\n@Directive({\n  selector: '[aclDragHandle]',\n})\nexport class DragHandleDirective {}\n\n@Directive({\n  selector: '[aclMutable]',\n})\nexport class MutableDirective {\n  private computedOptions: MutableOptions = MUTABLE_BASIC_OPTIONS;\n\n  /** Allow for stretch shrink, the default is open */\n  @Input() aclResizable = true;\n  /** Allow for drag and drop, the default is open */\n  @Input() aclDraggable = true;\n  /** Define drag boundary, as body */\n  @Input() aclDragBoundary: string | ElementRef<HTMLElement> | HTMLElement;\n\n  @Input()\n  set aclMutableOptions(options: MutableOptions) {\n    this.computedOptions = {\n      ...MUTABLE_BASIC_OPTIONS,\n      ...options,\n    };\n  }\n\n  /** In the process of the resize triggering events */\n  @Output()\n  readonly aclOnResize = new EventEmitter<HTMLElement>();\n\n  /** Drag in the process of the triggering event */\n  @Output() readonly aclOnDrag = new EventEmitter<HTMLElement>();\n  /** Emits when the user start drag. */\n  @Output() readonly aclDragStarted = new EventEmitter<HTMLElement>();\n  @Output() readonly aclDragEnded = new EventEmitter<HTMLElement>();\n  /** Emits when the user start resize */\n  @Output() readonly aclResizeStarted = new EventEmitter<HTMLElement>();\n  @Output() readonly aclResizeEnded = new EventEmitter<HTMLElement>();\n\n  @ContentChildren(DragHandleDirective, { read: ElementRef, descendants: true })\n  handles: QueryList<ElementRef>;\n\n  isDragging = false;\n\n  isResizingX = false;\n\n  isResizingY = false;\n\n  mousePoint = { x: 0, y: 0 };\n\n  parentBorder: { left: number; top: number };\n\n  elementBorder: { left: number; top: number; right: number; bottom: number };\n\n  element: HTMLElement = null;\n\n  private readonly _initCursor: string;\n\n  resizeCursor: ResizeCursor;\n  resizeInitXRight = 0;\n  resizeInitYBottom = 0;\n\n  @HostListener('document:mousedown', ['$event'])\n  onMouseDown(event: MouseEvent) {\n    if (!isSelfOrParent(event.target as HTMLElement, this.element)) {\n      return;\n    }\n    const cursor = this.getMutableCursor(event);\n\n    if (cursor === this.computedOptions.cursors.move) {\n      this.setDragging(cursor, event);\n      this.aclDragStarted.emit(this.element);\n    } else if (this.aclResizable && cursor.includes('-resize')) {\n      this.setResizing(cursor, event);\n      this.aclResizeStarted.emit(this.element);\n    }\n  }\n\n  @HostListener('document:mousemove', ['$event'])\n  onMouseMove(event: MouseEvent) {\n    this.element.style.cursor = this.getMutableCursor(event);\n\n    if (this.isDragging) {\n      this.dragElement(event);\n      this.aclOnDrag.emit(this.element);\n    }\n\n    if (this.isResizingX || this.isResizingY) {\n      this.isResizingX && this.resizeElementX(event);\n      this.isResizingY && this.resizeElementY(event);\n      this.aclOnResize.emit(this.element);\n    }\n  }\n\n  @HostListener('document:mouseup')\n  onMouseUp() {\n    if (this.aclDraggable) {\n      this.setDragging(null, null);\n      this.aclDragEnded.emit(this.element);\n    }\n\n    if (this.aclResizable) {\n      this.setResizing(null, null);\n      this.aclResizeEnded.emit(this.element);\n    }\n  }\n\n  constructor(private readonly el: ElementRef<HTMLElement>) {\n    this.element = this.el.nativeElement;\n    this._initCursor = this.element.style.cursor;\n  }\n\n  /** Gets the boundary element, based on the `boundaryElement` value. */\n  private getBoundaryElement() {\n    const boundary = this.aclDragBoundary;\n\n    if (!boundary) {\n      return this.element.parentNode as HTMLElement;\n    }\n\n    if (typeof boundary === 'string') {\n      return this.element.closest(boundary);\n    }\n\n    return coerceElement(boundary);\n  }\n\n  private ensureInParent(point: Point) {\n    const parent = this.getBoundaryElement();\n    const elementRect = this.element.getBoundingClientRect();\n    if (point.x < 0) {\n      point.x = 0;\n    } else if (point.x >= parent.clientWidth - elementRect.width) {\n      point.x = parent.clientWidth - elementRect.width;\n    }\n\n    if (point.y < 0) {\n      point.y = 0;\n    } else if (point.y >= parent.clientHeight - elementRect.height) {\n      point.y = parent.clientHeight - elementRect.height;\n    }\n    return point;\n  }\n\n  dragElement(event: MouseEvent) {\n    const parentElement = this.getBoundaryElement();\n    const parentRect = {\n      left:\n        parentElement.getBoundingClientRect().left + parentElement.scrollLeft,\n      top: parentElement.getBoundingClientRect().top + parentElement.scrollTop,\n    };\n\n    const { x, y } = this.ensureInParent({\n      x:\n        event.clientX -\n        parentRect.left -\n        this.parentBorder.left -\n        this.mousePoint.x,\n      y:\n        event.clientY -\n        parentRect.top -\n        this.parentBorder.top -\n        this.mousePoint.y,\n    });\n\n    if (this.computedOptions.dragRange) {\n      const [t, r, b, l] = this.computedOptions.dragRange.map((key, index) => {\n        if (typeof key === 'number') {\n          return (\n            (key / 100) *\n            ([1, 3].includes(index)\n              ? parentElement.clientWidth\n              : parentElement.clientHeight)\n          );\n        }\n        if (typeof key === 'string' && key.includes('px')) {\n          return toNumber(key);\n        }\n        console.error('DragRange in mutableOptions is invalid!');\n        return 0;\n      });\n      this.element.style.left = toPx(\n        Math.max(l, Math.min(x, parentElement.clientWidth - r)),\n      );\n      this.element.style.top = toPx(\n        Math.max(t, Math.min(y, parentElement.clientHeight - b)),\n      );\n      return;\n    }\n\n    this.element.style.left = toPx(x);\n    this.element.style.top = toPx(y);\n  }\n\n  initDragging(event: MouseEvent) {\n    const rect = this.element.getBoundingClientRect();\n\n    this.mousePoint.x = event.clientX - rect.left;\n\n    this.mousePoint.y = event.clientY - rect.top;\n\n    const { borderLeft, borderTop } = getComputedStyle(\n      this.getBoundaryElement(),\n    );\n\n    this.parentBorder = {\n      left: toNumber(borderLeft),\n      top: toNumber(borderTop),\n    };\n  }\n\n  setDragging(cursor: string, event: MouseEvent) {\n    this.isDragging = cursor === this.computedOptions.cursors.move;\n\n    if (this.isDragging) {\n      this.initDragging(event);\n    }\n  }\n\n  resizeElementX(event: MouseEvent) {\n    if (this.isResizeOutOfBoundary(event, 'horizontal')) {\n      return;\n    }\n\n    const elementRect = this.element.getBoundingClientRect();\n    let width;\n    const { minWidth, maxWidth, left } = getComputedStyle(this.element);\n    const computedMinWidth = Math.max(\n      toNumber(minWidth),\n      this.elementBorder.left + this.elementBorder.right,\n    );\n\n    if (isL(this.resizeCursor)) {\n      const targetLeft = event.clientX - this.mousePoint.x;\n      const computedWidth = this.resizeInitXRight - targetLeft;\n\n      width = Math.max(\n        toNumber(maxWidth)\n          ? Math.min(computedWidth, toNumber(maxWidth))\n          : computedWidth,\n        computedMinWidth,\n      );\n\n      this.element.style.left = toPx(\n        toNumber(left) + elementRect.width - width,\n      );\n    } else {\n      const targetRight = event.clientX + this.mousePoint.x;\n\n      const computedWidth = targetRight - elementRect.left;\n      width = Math.max(\n        toNumber(maxWidth)\n          ? Math.min(computedWidth, toNumber(maxWidth))\n          : computedWidth,\n        computedMinWidth,\n      );\n    }\n\n    if (width < this.elementBorder.left + this.elementBorder.right) {\n      return;\n    }\n\n    this.element.style.width = toPx(width);\n  }\n\n  resizeElementY(event: MouseEvent) {\n    if (this.isResizeOutOfBoundary(event, 'vertical')) {\n      return;\n    }\n\n    const elementRect = this.element.getBoundingClientRect();\n    const { minHeight, maxHeight, top } = getComputedStyle(this.element);\n    const computedMinHeight = Math.max(\n      toNumber(minHeight),\n      this.elementBorder.top + this.elementBorder.bottom,\n    );\n\n    let height;\n\n    if (isT(this.resizeCursor)) {\n      const targetTop = event.clientY - this.mousePoint.y;\n\n      const computedHeight = this.resizeInitYBottom - targetTop;\n\n      height = Math.max(\n        toNumber(maxHeight)\n          ? Math.min(computedHeight, toNumber(maxHeight))\n          : computedHeight,\n        computedMinHeight,\n      );\n\n      this.element.style.top = toPx(\n        toNumber(top) + elementRect.height - height,\n      );\n    } else {\n      const targetBottom = event.clientY + this.mousePoint.y;\n\n      const computedHeight = targetBottom - elementRect.top;\n\n      height = Math.max(\n        toNumber(maxHeight)\n          ? Math.min(computedHeight, toNumber(maxHeight))\n          : computedHeight,\n        computedMinHeight,\n      );\n    }\n    if (height < this.elementBorder.top + this.elementBorder.bottom) {\n      return;\n    }\n    this.element.style.height = toPx(height);\n  }\n\n  initResizing(event: MouseEvent) {\n    const elementRect = this.element.getBoundingClientRect();\n\n    this.resizeInitXRight = elementRect.right;\n    this.resizeInitYBottom = elementRect.bottom;\n\n    this.mousePoint.x = isL(this.resizeCursor)\n      ? event.clientX - elementRect.left\n      : elementRect.right - event.clientX;\n\n    this.mousePoint.y = isT(this.resizeCursor)\n      ? event.clientY - elementRect.top\n      : elementRect.bottom - event.clientY;\n\n    const { borderLeft, borderTop, borderBottom, borderRight } =\n      getComputedStyle(this.element);\n    this.elementBorder = {\n      left: toNumber(borderLeft),\n      top: toNumber(borderTop),\n      bottom: toNumber(borderBottom),\n      right: toNumber(borderRight),\n    };\n  }\n\n  setResizing(cursor: string, event: MouseEvent) {\n    if (cursor == null || !cursor.includes('-resize')) {\n      this.isResizingX = false;\n\n      this.isResizingY = false;\n\n      return;\n    }\n\n    cursor = cursor.replace('-resize', '');\n\n    this.isResizingX = cursor.includes('e') || cursor.includes('w');\n\n    this.isResizingY = cursor.includes('s') || cursor.includes('n');\n\n    this.initResizing(event);\n  }\n\n  // eslint-disable-next-line sonarjs/cognitive-complexity\n  getMutableCursor(event: MouseEvent): string {\n    if (this.isResizingX || this.isResizingY) {\n      return;\n    }\n    const elementRect = this.element.getBoundingClientRect();\n\n    const resizeThreshold = this.computedOptions.resizeThreshold;\n\n    const pt = {\n      x: event.clientX,\n      y: event.clientY,\n    };\n\n    let cursor = '';\n    const dragThreshold = this.aclResizable ? resizeThreshold : 0;\n\n    if (\n      this.aclDraggable &&\n      pt.x < elementRect.right - dragThreshold &&\n      pt.x > elementRect.left + dragThreshold &&\n      pt.y < elementRect.bottom - dragThreshold &&\n      pt.y > elementRect.top + dragThreshold &&\n      (!this.handles?.length ||\n        this.handles?.some(h =>\n          isSelfOrParent(event.target as HTMLElement, h.nativeElement),\n        ))\n    ) {\n      cursor = this.computedOptions.cursors.move;\n    }\n\n    if (this.aclResizable && !cursor) {\n      if (\n        pt.y >= elementRect.top &&\n        pt.y <= elementRect.top + resizeThreshold\n      ) {\n        cursor += 'n';\n      } else if (\n        pt.y >= elementRect.bottom - resizeThreshold &&\n        pt.y <= elementRect.bottom\n      ) {\n        cursor += 's';\n      }\n\n      if (\n        pt.x >= elementRect.left &&\n        pt.x <= elementRect.left + resizeThreshold\n      ) {\n        cursor += 'w';\n      } else if (\n        pt.x >= elementRect.right - resizeThreshold &&\n        pt.x <= elementRect.right\n      ) {\n        cursor += 'e';\n      }\n\n      cursor = cursor ? cursor + '-resize' : '';\n    }\n\n    this.resizeCursor = cursor as ResizeCursor;\n\n    return cursor || this._initCursor;\n  }\n\n  private isResizeOutOfBoundary(\n    event: MouseEvent,\n    direction: 'horizontal' | 'vertical',\n  ) {\n    const parentElement = this.getBoundaryElement();\n\n    const eventProp = direction === 'horizontal' ? 'clientX' : 'clientY';\n    const parentProp =\n      direction === 'horizontal' ? 'clientWidth' : 'clientHeight';\n\n    return event[eventProp] < 0 || event[eventProp] > parentElement[parentProp];\n  }\n}\n"]}

package/esm2022/mutable/mutable.module.mjs

@@ -0,0 +1,41 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MosaicComponent } from './mosaic/mosaic.component';
+import { MosaicLeftDirective, MosaicRightDirective, } from './mosaic/mosaic.directive';
+import { DragHandleDirective, MutableDirective } from './mutable.directive';
+import * as i0 from "@angular/core";
+export class MutableModule {
+    static { this.ɵfac = function MutableModule_Factory(t) { return new (t || MutableModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: MutableModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(MutableModule, [{
+        type: NgModule,
+        args: [{
+                imports: [CommonModule],
+                declarations: [
+                    MutableDirective,
+                    MosaicRightDirective,
+                    MosaicLeftDirective,
+                    DragHandleDirective,
+                    MosaicComponent,
+                ],
+                exports: [
+                    MutableDirective,
+                    MosaicRightDirective,
+                    MosaicLeftDirective,
+                    MosaicComponent,
+                    DragHandleDirective,
+                ],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(MutableModule, { declarations: [MutableDirective,
+        MosaicRightDirective,
+        MosaicLeftDirective,
+        DragHandleDirective,
+        MosaicComponent], imports: [CommonModule], exports: [MutableDirective,
+        MosaicRightDirective,
+        MosaicLeftDirective,
+        MosaicComponent,
+        DragHandleDirective] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/mutable/public-api.mjs

@@ -0,0 +1,6 @@
+export * from './mosaic/mosaic.component';
+export * from './mosaic/mosaic.directive';
+export * from './mutable.directive';
+export * from './mutable.module';
+export * from './util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9tdXRhYmxlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbW9zYWljL21vc2FpYy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9tb3NhaWMvbW9zYWljLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL211dGFibGUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vbXV0YWJsZS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsJztcbiJdfQ==

package/esm2022/mutable/util.mjs

@@ -0,0 +1,16 @@
+const removeSuffix = (str) => str.replace('-resize', '');
+/** 如果cursor存在类似 n-resize、ne-resize，都代表是top 方向 */
+export const isT = (cursor) => removeSuffix(cursor).includes('n');
+/** 是否是right */
+export const isR = (cursor) => removeSuffix(cursor).includes('e');
+/** 是否是bottom */
+export const isB = (cursor) => removeSuffix(cursor).includes('s');
+/** 是否是left */
+export const isL = (cursor) => removeSuffix(cursor).includes('w');
+export const toPx = (num) => num + 'px';
+export const toPercent = (num, base = 1) => num * base + '%';
+export const toNumber = (str) => {
+    const p = parseFloat(str);
+    return isNaN(p) ? 0 : p;
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/notification/errors-mapper.mjs

@@ -0,0 +1,28 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+export const ZH_ERRORS = {
+    Unknown: '未知错误',
+    Unauthorized: '授权不足',
+    Forbidden: '资源不可用',
+    NotFound: '找不到资源',
+    AlreadyExists: '资源已存在',
+    Conflict: '资源版本冲突，请重新获取资源',
+    Gone: '资源位置已变更',
+    Invalid: '数据错误',
+    ServerTimeout: '响应超时',
+    Timeout: '请求超时',
+    TooManyRequests: '请求太多，超过服务能力',
+    BadRequest: '无效的请求',
+    MethodNotAllowed: '请求的操作不被允许',
+    NotAcceptable: '接收的数据类型不被支持',
+    RequestEntityTooLarge: '请求实体太大',
+    UnsupportedMediaType: '发送的数据类型不被支持',
+    InternalError: '内部错误',
+    Expired: '请求内容已过期',
+    ServiceUnavailable: '当前请求的服务不可用，可稍后重试',
+    ProjectNamespaceConflict: '平台级命名空间已存在，请处理',
+};
+export const DEFAULT_ZH_ERROR = '网络错误';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/notification/feedback-notification/component.mjs

@@ -0,0 +1,95 @@
+/**
+ * @packageDocumentation
+ * @module notification
+ */
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import * as i0 from "@angular/core";
+function FeedbackNotificationComponent_main_0_pre_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "pre", 4);
+} if (rf & 2) {
+    const ctx_r3 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("innerHTML", ctx_r3.content, i0.ɵɵsanitizeHtml);
+} }
+function FeedbackNotificationComponent_main_0_div_2_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 4);
+} if (rf & 2) {
+    const ctx_r4 = i0.ɵɵnextContext(2);
+    i0.ɵɵproperty("innerHTML", ctx_r4.content, i0.ɵɵsanitizeHtml);
+} }
+function FeedbackNotificationComponent_main_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "main");
+    i0.ɵɵtemplate(1, FeedbackNotificationComponent_main_0_pre_1_Template, 1, 1, "pre", 3);
+    i0.ɵɵtemplate(2, FeedbackNotificationComponent_main_0_div_2_Template, 1, 1, "div", 3);
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r0 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", ctx_r0.pre);
+    i0.ɵɵadvance(1);
+    i0.ɵɵproperty("ngIf", !ctx_r0.pre);
+} }
+function FeedbackNotificationComponent_button_2_Template(rf, ctx) { if (rf & 1) {
+    const _r6 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 5);
+    i0.ɵɵlistener("click", function FeedbackNotificationComponent_button_2_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r6); const ctx_r5 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r5.onPrimary.emit()); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r1 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, ctx_r1.primary), " ");
+} }
+function FeedbackNotificationComponent_button_3_Template(rf, ctx) { if (rf & 1) {
+    const _r8 = i0.ɵɵgetCurrentView();
+    i0.ɵɵelementStart(0, "button", 6);
+    i0.ɵɵlistener("click", function FeedbackNotificationComponent_button_3_Template_button_click_0_listener() { i0.ɵɵrestoreView(_r8); const ctx_r7 = i0.ɵɵnextContext(); return i0.ɵɵresetView(ctx_r7.onSecondary.emit()); });
+    i0.ɵɵtext(1);
+    i0.ɵɵpipe(2, "translate");
+    i0.ɵɵelementEnd();
+} if (rf & 2) {
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(1);
+    i0.ɵɵtextInterpolate1(" ", i0.ɵɵpipeBind1(2, 1, ctx_r2.secondary), " ");
+} }
+export class FeedbackNotificationComponent {
+    constructor() {
+        this.onPrimary = new EventEmitter();
+        this.onSecondary = new EventEmitter();
+    }
+    static { this.ɵfac = function FeedbackNotificationComponent_Factory(t) { return new (t || FeedbackNotificationComponent)(); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: FeedbackNotificationComponent, selectors: [["ng-component"]], inputs: { primary: "primary", secondary: "secondary", content: "content", pre: "pre" }, outputs: { onPrimary: "onPrimary", onSecondary: "onSecondary" }, decls: 4, vars: 3, consts: [[4, "ngIf"], ["aui-button", "primary", "type", "button", "size", "mini", 3, "click", 4, "ngIf"], ["aui-button", "default", "type", "button", "size", "mini", 3, "click", 4, "ngIf"], [3, "innerHTML", 4, "ngIf"], [3, "innerHTML"], ["aui-button", "primary", "type", "button", "size", "mini", 3, "click"], ["aui-button", "default", "type", "button", "size", "mini", 3, "click"]], template: function FeedbackNotificationComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, FeedbackNotificationComponent_main_0_Template, 3, 2, "main", 0);
+            i0.ɵɵelementStart(1, "footer");
+            i0.ɵɵtemplate(2, FeedbackNotificationComponent_button_2_Template, 3, 3, "button", 1);
+            i0.ɵɵtemplate(3, FeedbackNotificationComponent_button_3_Template, 3, 3, "button", 2);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx.content);
+            i0.ɵɵadvance(2);
+            i0.ɵɵproperty("ngIf", ctx.primary);
+            i0.ɵɵadvance(1);
+            i0.ɵɵproperty("ngIf", ctx.secondary);
+        } }, styles: ["[_nghost-%COMP%]{display:flex;flex-direction:column;max-height:150px}main[_ngcontent-%COMP%]{display:flex;flex:1;overflow:hidden}main[_ngcontent-%COMP%] > *[_ngcontent-%COMP%]{flex:1;overflow:auto}footer[_ngcontent-%COMP%]{padding-top:12px}"], changeDetection: 0 }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeedbackNotificationComponent, [{
+        type: Component,
+        args: [{ preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, template: "<main *ngIf=\"content\">\n  <pre\n    *ngIf=\"pre\"\n    [innerHTML]=\"content\"\n  ></pre>\n  <div\n    *ngIf=\"!pre\"\n    [innerHTML]=\"content\"\n  ></div>\n</main>\n<footer>\n  <button\n    *ngIf=\"primary\"\n    aui-button=\"primary\"\n    type=\"button\"\n    size=\"mini\"\n    (click)=\"onPrimary.emit()\"\n  >\n    {{ primary | translate }}\n  </button>\n  <button\n    *ngIf=\"secondary\"\n    aui-button=\"default\"\n    type=\"button\"\n    size=\"mini\"\n    (click)=\"onSecondary.emit()\"\n  >\n    {{ secondary | translate }}\n  </button>\n</footer>\n", styles: [":host{display:flex;flex-direction:column;max-height:150px}main{display:flex;flex:1;overflow:hidden}main>*{flex:1;overflow:auto}footer{padding-top:12px}\n"] }]
+    }], null, { primary: [{
+            type: Input
+        }], secondary: [{
+            type: Input
+        }], content: [{
+            type: Input
+        }], pre: [{
+            type: Input
+        }], 
+    // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+    onPrimary: [{
+            type: Output
+        }], 
+    // eslint-disable-next-line @angular-eslint/no-output-on-prefix
+    onSecondary: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/notification/helpers.mjs

@@ -0,0 +1,4 @@
+export function isK8sErrorStatus(e) {
+    return e?.metadata && e.apiVersion && e.kind === 'Status' && e.status;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGVscGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9ub3RpZmljYXRpb24vaGVscGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsQ0FBTTtJQUNyQyxPQUFPLENBQUMsRUFBRSxRQUFRLElBQUksQ0FBQyxDQUFDLFVBQVUsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxDQUFDLENBQUMsTUFBTSxDQUFDO0FBQ3hFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTdGF0dXMgfSBmcm9tICcuLi9jb3JlJztcblxuZXhwb3J0IGZ1bmN0aW9uIGlzSzhzRXJyb3JTdGF0dXMoZTogYW55KTogZSBpcyBTdGF0dXMge1xuICByZXR1cm4gZT8ubWV0YWRhdGEgJiYgZS5hcGlWZXJzaW9uICYmIGUua2luZCA9PT0gJ1N0YXR1cycgJiYgZS5zdGF0dXM7XG59XG4iXX0=