@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.12 → 0.0.1-alpha.14

package/esm2022/components/mutable/directive.mjs

@@ -0,0 +1,351 @@
+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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DragHandleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: DragHandleDirective, isStandalone: true, selector: "[aclDragHandle]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DragHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclDragHandle]',
+                    standalone: true,
+                }]
+        }] });
+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 = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MutableDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MutableDirective, isStandalone: true, selector: "[aclMutable]", inputs: { aclResizable: "aclResizable", aclDraggable: "aclDraggable", aclDragBoundary: "aclDragBoundary", aclMutableOptions: "aclMutableOptions" }, outputs: { aclOnResize: "aclOnResize", aclOnDrag: "aclOnDrag", aclDragStarted: "aclDragStarted", aclDragEnded: "aclDragEnded", aclResizeStarted: "aclResizeStarted", aclResizeEnded: "aclResizeEnded" }, host: { listeners: { "document:mousedown": "onMouseDown($event)", "document:mousemove": "onMouseMove($event)", "document:mouseup": "onMouseUp()" } }, queries: [{ propertyName: "handles", predicate: DragHandleDirective, descendants: true, read: ElementRef }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MutableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclMutable]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }], propDecorators: { 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":"directive.js","sourceRoot":"","sources":["../../../../../../libs/dynamic-plugin-shared/src/components/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  standalone: true,\n})\nexport class DragHandleDirective {}\n\n@Directive({\n  selector: '[aclMutable]',\n  standalone: true,\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/components/mutable/element.mjs

@@ -0,0 +1,23 @@
+import { ElementRef } from '@angular/core';
+/**
+ * To judge whether the parent element
+ */
+export const isSelfOrParent = (element, target) => {
+    while (element) {
+        if (element === target) {
+            return true;
+        }
+        element = element.parentNode;
+    }
+    return false;
+};
+/**
+ * Coerces an ElementRef or an Element into an element.
+ * Useful for APIs that can accept either a ref or the native element itself.
+ */
+export function coerceElement(elementOrRef) {
+    return elementOrRef instanceof ElementRef
+        ? elementOrRef.nativeElement
+        : elementOrRef;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZWxlbWVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZHluYW1pYy1wbHVnaW4tc2hhcmVkL3NyYy9jb21wb25lbnRzL211dGFibGUvZWxlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsT0FBb0IsRUFBRSxNQUFtQixFQUFFLEVBQUU7SUFDMUUsT0FBTyxPQUFPLEVBQUUsQ0FBQztRQUNmLElBQUksT0FBTyxLQUFLLE1BQU0sRUFBRSxDQUFDO1lBQ3ZCLE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUVELE9BQU8sR0FBRyxPQUFPLENBQUMsVUFBeUIsQ0FBQztJQUM5QyxDQUFDO0lBRUQsT0FBTyxLQUFLLENBQUM7QUFDZixDQUFDLENBQUM7QUFFRjs7O0dBR0c7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFJLFlBQStCO0lBQzlELE9BQU8sWUFBWSxZQUFZLFVBQVU7UUFDdkMsQ0FBQyxDQUFDLFlBQVksQ0FBQyxhQUFhO1FBQzVCLENBQUMsQ0FBQyxZQUFZLENBQUM7QUFDbkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLyoqXG4gKiBUbyBqdWRnZSB3aGV0aGVyIHRoZSBwYXJlbnQgZWxlbWVudFxuICovXG5leHBvcnQgY29uc3QgaXNTZWxmT3JQYXJlbnQgPSAoZWxlbWVudDogSFRNTEVsZW1lbnQsIHRhcmdldDogSFRNTEVsZW1lbnQpID0+IHtcbiAgd2hpbGUgKGVsZW1lbnQpIHtcbiAgICBpZiAoZWxlbWVudCA9PT0gdGFyZ2V0KSB7XG4gICAgICByZXR1cm4gdHJ1ZTtcbiAgICB9XG5cbiAgICBlbGVtZW50ID0gZWxlbWVudC5wYXJlbnROb2RlIGFzIEhUTUxFbGVtZW50O1xuICB9XG5cbiAgcmV0dXJuIGZhbHNlO1xufTtcblxuLyoqXG4gKiBDb2VyY2VzIGFuIEVsZW1lbnRSZWYgb3IgYW4gRWxlbWVudCBpbnRvIGFuIGVsZW1lbnQuXG4gKiBVc2VmdWwgZm9yIEFQSXMgdGhhdCBjYW4gYWNjZXB0IGVpdGhlciBhIHJlZiBvciB0aGUgbmF0aXZlIGVsZW1lbnQgaXRzZWxmLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY29lcmNlRWxlbWVudDxUPihlbGVtZW50T3JSZWY6IEVsZW1lbnRSZWY8VD4gfCBUKTogVCB7XG4gIHJldHVybiBlbGVtZW50T3JSZWYgaW5zdGFuY2VvZiBFbGVtZW50UmVmXG4gICAgPyBlbGVtZW50T3JSZWYubmF0aXZlRWxlbWVudFxuICAgIDogZWxlbWVudE9yUmVmO1xufVxuIl19

package/esm2022/components/mutable/index.mjs

@@ -0,0 +1,15 @@
+import { MosaicComponent } from './mosaic/component';
+import { MosaicLeftDirective, MosaicRightDirective } from './mosaic/directive';
+import { DragHandleDirective, MutableDirective } from './directive';
+export * from './mosaic/component';
+export * from './mosaic/directive';
+export * from './directive';
+export * from './util';
+export const MUTABLE_MODULE = [
+    MutableDirective,
+    MosaicRightDirective,
+    MosaicLeftDirective,
+    MosaicComponent,
+    DragHandleDirective,
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvY29tcG9uZW50cy9tdXRhYmxlL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNyRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMvRSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFcEUsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsUUFBUSxDQUFDO0FBQ3ZCLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRztJQUM1QixnQkFBZ0I7SUFDaEIsb0JBQW9CO0lBQ3BCLG1CQUFtQjtJQUNuQixlQUFlO0lBQ2YsbUJBQW1CO0NBQ1gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vc2FpY0NvbXBvbmVudCB9IGZyb20gJy4vbW9zYWljL2NvbXBvbmVudCc7XG5pbXBvcnQgeyBNb3NhaWNMZWZ0RGlyZWN0aXZlLCBNb3NhaWNSaWdodERpcmVjdGl2ZSB9IGZyb20gJy4vbW9zYWljL2RpcmVjdGl2ZSc7XG5pbXBvcnQgeyBEcmFnSGFuZGxlRGlyZWN0aXZlLCBNdXRhYmxlRGlyZWN0aXZlIH0gZnJvbSAnLi9kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL21vc2FpYy9jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9tb3NhaWMvZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbCc7XG5leHBvcnQgY29uc3QgTVVUQUJMRV9NT0RVTEUgPSBbXG4gIE11dGFibGVEaXJlY3RpdmUsXG4gIE1vc2FpY1JpZ2h0RGlyZWN0aXZlLFxuICBNb3NhaWNMZWZ0RGlyZWN0aXZlLFxuICBNb3NhaWNDb21wb25lbnQsXG4gIERyYWdIYW5kbGVEaXJlY3RpdmUsXG5dIGFzIGNvbnN0O1xuIl19

package/esm2022/components/mutable/mosaic/component.mjs

@@ -0,0 +1,76 @@
+import { __decorate, __metadata } from "tslib";
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { MonacoEditorConfig } from 'ng-monaco-editor';
+import { Observable, combineLatest, map } from 'rxjs';
+import { toNumber, toPercent } from '../util';
+import { ObservableInput, publishRef } from '../../../utils';
+import { MutableDirective } from '../directive';
+import { AsyncPipe, NgStyle } from '@angular/common';
+import * as i0 from "@angular/core";
+export class MosaicComponent {
+    constructor() {
+        this.left = 0;
+        this.right = 0;
+        this.splitLocation = 50;
+        this.mutableOptions$ = combineLatest([this.left$, this.right$]).pipe(map(([left, right]) => ({
+            dragRange: [0, right, 100, left],
+            cursors: {
+                move: 'col-resize',
+            },
+        })), publishRef());
+        this.leftInset = {
+            top: '0',
+            right: toPercent(this.splitLocation),
+            bottom: '0',
+            left: '0',
+        };
+        this.rightInset = {
+            top: '0',
+            right: '0',
+            bottom: '0',
+            left: toPercent(100 - this.splitLocation),
+        };
+        this.splitInset = this.rightInset;
+    }
+    drag(element, root) {
+        requestAnimationFrame(() => {
+            this.leftInset = {
+                top: '0',
+                right: toPercent(1 - toNumber(element.style.left) / root.clientWidth, 100),
+                bottom: '0',
+                left: '0',
+            };
+            this.rightInset = {
+                top: '0',
+                right: '0',
+                bottom: '0',
+                left: toPercent(toNumber(element.style.left) / root.clientWidth, 100),
+            };
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: MosaicComponent, isStandalone: true, selector: "acl-mosaic", inputs: { left: "left", right: "right", splitLocation: "splitLocation" }, providers: [
+            { provide: MonacoEditorConfig, useValue: { autoLayoutInterval: 1 } },
+        ], ngImport: i0, template: "<div\n  class=\"mosaic-root\"\n  #root\n>\n  <div\n    class=\"mosaic-left\"\n    [ngStyle]=\"leftInset\"\n  >\n    <ng-content select=\"[aclMosaicLeft]\"></ng-content>\n  </div>\n  <div\n    class=\"mosaic-split\"\n    [ngStyle]=\"splitInset\"\n    aclMutable\n    (aclOnDrag)=\"drag($event, root)\"\n    [aclMutableOptions]=\"mutableOptions$ | async\"\n    [aclResizable]=\"false\"\n  ></div>\n  <div\n    class=\"mosaic-right\"\n    [ngStyle]=\"rightInset\"\n  >\n    <ng-content select=\"[aclMosaicRight]\"></ng-content>\n  </div>\n</div>\n", styles: [".mosaic-root{position:relative;width:100%;min-height:400px;overflow:hidden}.mosaic-split{position:absolute;margin-left:-1px;width:2px;z-index:1;background-color:rgb(var(--aui-color-n-10))}.mosaic-split:hover{width:4px;margin-left:-2px}.mosaic-left,.mosaic-right{height:100%;position:absolute}.mutable-box{width:50px;height:50px;position:absolute;background-color:#444}\n"], dependencies: [{ kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "pipe", type: AsyncPipe, name: "async" }, { kind: "directive", type: MutableDirective, selector: "[aclMutable]", inputs: ["aclResizable", "aclDraggable", "aclDragBoundary", "aclMutableOptions"], outputs: ["aclOnResize", "aclOnDrag", "aclDragStarted", "aclDragEnded", "aclResizeStarted", "aclResizeEnded"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MosaicComponent.prototype, "left$", void 0);
+__decorate([
+    ObservableInput(),
+    __metadata("design:type", Observable)
+], MosaicComponent.prototype, "right$", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-mosaic', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [NgStyle, AsyncPipe, MutableDirective], providers: [
+                        { provide: MonacoEditorConfig, useValue: { autoLayoutInterval: 1 } },
+                    ], template: "<div\n  class=\"mosaic-root\"\n  #root\n>\n  <div\n    class=\"mosaic-left\"\n    [ngStyle]=\"leftInset\"\n  >\n    <ng-content select=\"[aclMosaicLeft]\"></ng-content>\n  </div>\n  <div\n    class=\"mosaic-split\"\n    [ngStyle]=\"splitInset\"\n    aclMutable\n    (aclOnDrag)=\"drag($event, root)\"\n    [aclMutableOptions]=\"mutableOptions$ | async\"\n    [aclResizable]=\"false\"\n  ></div>\n  <div\n    class=\"mosaic-right\"\n    [ngStyle]=\"rightInset\"\n  >\n    <ng-content select=\"[aclMosaicRight]\"></ng-content>\n  </div>\n</div>\n", styles: [".mosaic-root{position:relative;width:100%;min-height:400px;overflow:hidden}.mosaic-split{position:absolute;margin-left:-1px;width:2px;z-index:1;background-color:rgb(var(--aui-color-n-10))}.mosaic-split:hover{width:4px;margin-left:-2px}.mosaic-left,.mosaic-right{height:100%;position:absolute}.mutable-box{width:50px;height:50px;position:absolute;background-color:#444}\n"] }]
+        }], propDecorators: { left: [{
+                type: Input
+            }], left$: [], right: [{
+                type: Input
+            }], right$: [], splitLocation: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/mutable/mosaic/directive.mjs

@@ -0,0 +1,24 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class MosaicLeftDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicLeftDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MosaicLeftDirective, selector: "acl-mosaic[aclMosaicLeft]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicLeftDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'acl-mosaic[aclMosaicLeft]',
+                }]
+        }] });
+export class MosaicRightDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicRightDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MosaicRightDirective, isStandalone: true, selector: "acl-mosaic[aclMosaicRight]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MosaicRightDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'acl-mosaic[aclMosaicRight]',
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2NvbXBvbmVudHMvbXV0YWJsZS9tb3NhaWMvZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSzFDLE1BQU0sT0FBTyxtQkFBbUI7OEdBQW5CLG1CQUFtQjtrR0FBbkIsbUJBQW1COzsyRkFBbkIsbUJBQW1CO2tCQUgvQixTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSwyQkFBMkI7aUJBQ3RDOztBQU9ELE1BQU0sT0FBTyxvQkFBb0I7OEdBQXBCLG9CQUFvQjtrR0FBcEIsb0JBQW9COzsyRkFBcEIsb0JBQW9CO2tCQUpoQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSw0QkFBNEI7b0JBQ3RDLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdhY2wtbW9zYWljW2FjbE1vc2FpY0xlZnRdJyxcbn0pXG5leHBvcnQgY2xhc3MgTW9zYWljTGVmdERpcmVjdGl2ZSB7fVxuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdhY2wtbW9zYWljW2FjbE1vc2FpY1JpZ2h0XScsXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIE1vc2FpY1JpZ2h0RGlyZWN0aXZlIHt9XG4iXX0=

package/esm2022/components/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvZHluYW1pYy1wbHVnaW4tc2hhcmVkL3NyYy9jb21wb25lbnRzL211dGFibGUvdXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxNQUFNLFlBQVksR0FBRyxDQUFDLEdBQWlCLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQyxPQUFPLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDO0FBQ3ZFLGlEQUFpRDtBQUNqRCxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFvQixFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2hGLGVBQWU7QUFDZixNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFvQixFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2hGLGdCQUFnQjtBQUNoQixNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFvQixFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBQ2hGLGNBQWM7QUFDZCxNQUFNLENBQUMsTUFBTSxHQUFHLEdBQUcsQ0FBQyxNQUFvQixFQUFFLEVBQUUsQ0FBQyxZQUFZLENBQUMsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0FBRWhGLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxDQUFDLEdBQVcsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQztBQUNoRCxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsQ0FBQyxHQUFXLEVBQUUsSUFBSSxHQUFHLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLElBQUksR0FBRyxHQUFHLENBQUM7QUFDckUsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLENBQUMsR0FBVyxFQUFFLEVBQUU7SUFDdEMsTUFBTSxDQUFDLEdBQUcsVUFBVSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQzFCLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztBQUMxQixDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIGN1cnNvciBzdHlsZSBsaW5rIGh0dHBzOi8vZGV2ZWxvcGVyLm1vemlsbGEub3JnL3poLUNOL2RvY3MvV2ViL0NTUy9jdXJzb3JcbiAqL1xuZXhwb3J0IHR5cGUgQ3Vyc29yWCA9ICdlJyB8ICd3JztcbmV4cG9ydCB0eXBlIEN1cnNvclkgPSAnbicgfCAncyc7XG5cbmV4cG9ydCB0eXBlIEN1cnNvciA9IEN1cnNvclggfCBDdXJzb3JZIHwgYCR7Q3Vyc29yWX0ke0N1cnNvclh9YDtcbmV4cG9ydCB0eXBlIFJlc2l6ZUN1cnNvciA9IGAke0N1cnNvcn0tcmVzaXplYDtcblxuY29uc3QgcmVtb3ZlU3VmZml4ID0gKHN0cjogUmVzaXplQ3Vyc29yKSA9PiBzdHIucmVwbGFjZSgnLXJlc2l6ZScsICcnKTtcbi8qKiDlpoLmnpxjdXJzb3LlrZjlnKjnsbvkvLwgbi1yZXNpemXjgIFuZS1yZXNpemXvvIzpg73ku6PooajmmK90b3Ag5pa55ZCRICovXG5leHBvcnQgY29uc3QgaXNUID0gKGN1cnNvcjogUmVzaXplQ3Vyc29yKSA9PiByZW1vdmVTdWZmaXgoY3Vyc29yKS5pbmNsdWRlcygnbicpO1xuLyoqIOaYr+WQpuaYr3JpZ2h0ICovXG5leHBvcnQgY29uc3QgaXNSID0gKGN1cnNvcjogUmVzaXplQ3Vyc29yKSA9PiByZW1vdmVTdWZmaXgoY3Vyc29yKS5pbmNsdWRlcygnZScpO1xuLyoqIOaYr+WQpuaYr2JvdHRvbSAqL1xuZXhwb3J0IGNvbnN0IGlzQiA9IChjdXJzb3I6IFJlc2l6ZUN1cnNvcikgPT4gcmVtb3ZlU3VmZml4KGN1cnNvcikuaW5jbHVkZXMoJ3MnKTtcbi8qKiDmmK/lkKbmmK9sZWZ0ICovXG5leHBvcnQgY29uc3QgaXNMID0gKGN1cnNvcjogUmVzaXplQ3Vyc29yKSA9PiByZW1vdmVTdWZmaXgoY3Vyc29yKS5pbmNsdWRlcygndycpO1xuXG5leHBvcnQgY29uc3QgdG9QeCA9IChudW06IG51bWJlcikgPT4gbnVtICsgJ3B4JztcbmV4cG9ydCBjb25zdCB0b1BlcmNlbnQgPSAobnVtOiBudW1iZXIsIGJhc2UgPSAxKSA9PiBudW0gKiBiYXNlICsgJyUnO1xuZXhwb3J0IGNvbnN0IHRvTnVtYmVyID0gKHN0cjogc3RyaW5nKSA9PiB7XG4gIGNvbnN0IHAgPSBwYXJzZUZsb2F0KHN0cik7XG4gIHJldHVybiBpc05hTihwKSA/IDAgOiBwO1xufTtcbiJdfQ==

package/esm2022/components/overview-banner/component.mjs

@@ -0,0 +1,17 @@
+import { IconComponent } from '@alauda/ui';
+import { Component, Input, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+export class OverviewBannerComponent {
+    constructor() {
+        this.option = {};
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OverviewBannerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: OverviewBannerComponent, isStandalone: true, selector: "acl-overview-banner", inputs: { option: "option" }, ngImport: i0, template: "<div class=\"overview-banner--wrapper\">\n  <div class=\"overview-banner\">\n    <div class=\"overview-banner__icon\">\n      <aui-icon\n        class=\"acl-colorful-icon highlight\"\n        [icon]=\"'bicolor:' + option?.icon\"\n      ></aui-icon>\n    </div>\n    <div class=\"overview-banner__content\">\n      <div class=\"overview-banner__title\">\n        {{ option?.title }}\n      </div>\n      <div class=\"overview-banner__description\">\n        {{ option?.description }}\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".overview-banner{display:flex;align-items:center;padding:24px}.overview-banner--wrapper{border-radius:var(--aui-border-radius-l);margin-bottom:var(--aui-spacing-xl);background-color:rgb(var(--aui-color-primary));background-image:url(/assets/images/overview-banner.svg);background-size:cover;background-position:center}.overview-banner__icon{margin-right:20px}.overview-banner__icon aui-icon{display:flex;font-size:56px;width:1em;height:1em}.overview-banner__content{color:#fff}.overview-banner__title{font-size:24px;line-height:36px;font-weight:var(--aui-font-weight-bolder)}.overview-banner__description{margin-top:4px;font-size:var(--aui-font-size-m)}\n"], dependencies: [{ kind: "component", type: IconComponent, selector: "aui-icon", inputs: ["icon", "light", "dark", "link", "margin", "size", "color", "background", "backgroundColor"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: OverviewBannerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-overview-banner', preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [IconComponent], template: "<div class=\"overview-banner--wrapper\">\n  <div class=\"overview-banner\">\n    <div class=\"overview-banner__icon\">\n      <aui-icon\n        class=\"acl-colorful-icon highlight\"\n        [icon]=\"'bicolor:' + option?.icon\"\n      ></aui-icon>\n    </div>\n    <div class=\"overview-banner__content\">\n      <div class=\"overview-banner__title\">\n        {{ option?.title }}\n      </div>\n      <div class=\"overview-banner__description\">\n        {{ option?.description }}\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".overview-banner{display:flex;align-items:center;padding:24px}.overview-banner--wrapper{border-radius:var(--aui-border-radius-l);margin-bottom:var(--aui-spacing-xl);background-color:rgb(var(--aui-color-primary));background-image:url(/assets/images/overview-banner.svg);background-size:cover;background-position:center}.overview-banner__icon{margin-right:20px}.overview-banner__icon aui-icon{display:flex;font-size:56px;width:1em;height:1em}.overview-banner__content{color:#fff}.overview-banner__title{font-size:24px;line-height:36px;font-weight:var(--aui-font-weight-bolder)}.overview-banner__description{margin-top:4px;font-size:var(--aui-font-size-m)}\n"] }]
+        }], propDecorators: { option: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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