@ng-nest/ui 15.0.20 → 16.0.0

package/esm2022/resizable/resizable.directive.mjs

@@ -0,0 +1,268 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, HostBinding, HostListener, inject } from '@angular/core';
+import { XComputed, XIsArray, XIsChange, XIsString } from '@ng-nest/ui/core';
+import { fromEvent, takeUntil } from 'rxjs';
+import { XResizablePrefix, XResizableProperty } from './resizable.property';
+import * as i0 from "@angular/core";
+class XResizableDirective extends XResizableProperty {
+    get getDisabled() {
+        return !this.xResizable;
+    }
+    constructor(renderer, elementRef) {
+        super();
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.document = inject(DOCUMENT);
+        this.cornerPositions = ['top-start', 'top-end', 'bottom-start', 'bottom-end'];
+        this.allPositions = ['left', 'right', 'top', 'bottom', ...this.cornerPositions];
+        this.positions = [];
+        this.newBox = { clientWidth: 0, clientHeight: 0, offsetLeft: 0, offsetTop: 0 };
+        this.positionNodes = {};
+        this.activatingNodes = [];
+        this.firstLoaded = true;
+        this.ele = this.elementRef.nativeElement;
+    }
+    ngOnInit() {
+        this.setMapClass();
+    }
+    ngAfterViewInit() {
+        this.setPosition();
+    }
+    ngOnDestroy() {
+        this.destroySubscription();
+    }
+    ngOnChanges(changes) {
+        const { xResizable } = changes;
+        XIsChange(xResizable) && this.setPosition();
+    }
+    mousedown(event) {
+        if (!this.xResizable)
+            return;
+        const classList = event.target.classList;
+        let direction = null;
+        for (let pos of this.allPositions) {
+            if (classList.contains(`x-resizable-${pos}`)) {
+                direction = pos;
+                break;
+            }
+        }
+        if (!direction)
+            return;
+        const evt = event.type.startsWith('touch') ? event.targetTouches[0] : event;
+        const { clientWidth, clientHeight, offsetLeft, offsetTop } = this.ele;
+        const { screenX, screenY } = evt;
+        const isTouchEvent = event.type.startsWith('touch');
+        const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';
+        const upEvent = isTouchEvent ? 'touchend' : 'mouseup';
+        this.setActivatingNodes(direction);
+        this.initResize(event, direction);
+        const mouseup = fromEvent(this.document, upEvent);
+        this.mouseUpSub = mouseup.subscribe((ev) => {
+            this.mouseup(ev);
+        });
+        const mouseMoveSub = fromEvent(document, moveEvent)
+            .pipe(takeUntil(mouseup))
+            .subscribe((ev) => this.move(ev, clientWidth, clientHeight, offsetTop, offsetLeft, screenX, screenY));
+        this.mouseUpSub.add(mouseMoveSub);
+    }
+    setMapClass() {
+        this.renderer.addClass(this.ele, XResizablePrefix);
+    }
+    setPosition() {
+        if (!this.xResizable || !this.firstLoaded)
+            return;
+        let positions = [];
+        if (XIsString(this.position)) {
+            positions.push(this.position);
+        }
+        else if (XIsArray(this.position)) {
+            positions = this.position;
+        }
+        if (positions.includes('all')) {
+            this.positions = this.allPositions;
+        }
+        else {
+            this.positions = positions;
+        }
+        this.createNode(...this.positions);
+        const computedStyle = XComputed(this.ele);
+        setTimeout(() => {
+            this.minWidth = parseFloat(computedStyle.minWidth);
+            this.maxWidth = parseFloat(computedStyle.maxWidth);
+            this.minHeight = parseFloat(computedStyle.minHeight);
+            this.maxHeight = parseFloat(computedStyle.maxHeight);
+            this.firstLoaded = false;
+        });
+    }
+    setActivatingNodes(direction) {
+        if (!this.positions.includes(direction))
+            return;
+        const addActivatingNode = (...direction) => {
+            for (let item of direction) {
+                const nd = this.positionNodes[item];
+                const isNd = this.activatingNodes.includes(nd);
+                if (!nd || isNd)
+                    continue;
+                this.renderer.addClass(nd, 'x-resizable-activating');
+                this.activatingNodes.push(nd);
+            }
+        };
+        if (this.cornerPositions.includes(direction)) {
+            switch (direction) {
+                case 'bottom-end':
+                    addActivatingNode('bottom', 'right');
+                    break;
+                case 'top-end':
+                    addActivatingNode('top', 'right');
+                    break;
+                case 'bottom-start':
+                    addActivatingNode('bottom', 'left');
+                    break;
+                case 'top-start':
+                    addActivatingNode('top', 'left');
+                    break;
+            }
+        }
+        addActivatingNode(direction);
+    }
+    createNode(...classes) {
+        for (let cla of classes) {
+            const pos = this.renderer.createElement('div');
+            this.renderer.addClass(pos, `x-resizable-${cla}`);
+            this.renderer.appendChild(this.ele, pos);
+            this.positionNodes[cla] = pos;
+        }
+    }
+    initResize(event, direction) {
+        this.direction = direction;
+        this.renderer.addClass(this.ele, `x-resizable-resizing`);
+        let { clientWidth, clientHeight, offsetLeft, offsetTop } = this.ele;
+        this.newBox = { clientWidth, clientHeight, offsetLeft, offsetTop };
+        event.stopPropagation();
+        this.resizeBegin.emit();
+    }
+    mouseup(event) {
+        this.endResize(event);
+        this.destroySubscription();
+    }
+    endResize(event) {
+        const evt = event.type.startsWith('touch') ? event.targetTouches[0] : event;
+        this.direction = null;
+        this.renderer.removeClass(this.ele, `x-resizable-resizing`);
+        for (const node of this.activatingNodes) {
+            this.renderer.removeClass(node, 'x-resizable-activating');
+        }
+        this.activatingNodes = [];
+        this.resizeEnd.emit({ event: evt, ...this.newBox });
+    }
+    move(event, width, height, top, left, screenX, screenY) {
+        const evt = event.type.startsWith('touch') ? event.targetTouches[0] : event;
+        const movementX = evt.screenX - screenX;
+        const movementY = evt.screenY - screenY;
+        this.newBox = {
+            clientWidth: width - (['bottom-start', 'left', 'top-start'].includes(this.direction) ? movementX : -movementX),
+            clientHeight: height - (['top-start', 'top', 'top-end'].includes(this.direction) ? movementY : -movementY),
+            offsetLeft: left + movementX,
+            offsetTop: top + movementY
+        };
+        const box = {
+            ...this.newBox,
+            offsetLeft: this.newBox.offsetLeft - Number(this.offsetLeft),
+            offsetTop: this.newBox.offsetTop - Number(this.offsetTop)
+        };
+        this.resizeBox(box);
+        this.resizing.emit({ ...this.newBox, event: evt, direction: this.direction });
+    }
+    resizeBox(box) {
+        if (this.ghost)
+            return;
+        const overMinWidth = !this.minWidth || box.clientWidth >= this.minWidth;
+        const underMaxWidth = !this.maxWidth || box.clientWidth <= this.maxWidth;
+        const overMinHeight = !this.minHeight || box.clientHeight >= this.minHeight;
+        const underMaxHeight = !this.maxHeight || box.clientHeight <= this.maxHeight;
+        switch (this.direction) {
+            case 'right':
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                break;
+            case 'top-end':
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+            case 'bottom-end':
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+            case 'bottom-start':
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+            case 'left':
+                console.log(this.minWidth);
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                break;
+            case 'top-start':
+                if (overMinWidth && underMaxWidth) {
+                    this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);
+                    this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);
+                }
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+            case 'top':
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+            case 'bottom':
+                if (overMinHeight && underMaxHeight) {
+                    this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);
+                }
+                break;
+        }
+    }
+    destroySubscription() {
+        if (this.mouseUpSub) {
+            this.mouseUpSub.unsubscribe();
+            this.mouseUpSub = undefined;
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: XResizableDirective, selector: "[xResizable]", host: { listeners: { "mousedown": "mousedown($event)", "touchstart": "mousedown($event)" }, properties: { "class.x-resizable-disabled": "this.getDisabled" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+export { XResizableDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[xResizable]' }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }]; }, propDecorators: { getDisabled: [{
+                type: HostBinding,
+                args: ['class.x-resizable-disabled']
+            }], mousedown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }, {
+                type: HostListener,
+                args: ['touchstart', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable.directive.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/resizable/resizable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport {\r\n  Directive,\r\n  ElementRef,\r\n  HostBinding,\r\n  HostListener,\r\n  OnDestroy,\r\n  OnInit,\r\n  Renderer2,\r\n  SimpleChanges,\r\n  inject\r\n} from '@angular/core';\r\nimport { XComputed, XIsArray, XIsChange, XIsString } from '@ng-nest/ui/core';\r\nimport { fromEvent, Subscription, takeUntil } from 'rxjs';\r\nimport { XResizablePosition, XResizablePrefix, XResizableProperty } from './resizable.property';\r\n\r\n@Directive({ selector: '[xResizable]' })\r\nexport class XResizableDirective extends XResizableProperty implements OnInit, OnDestroy {\r\n  @HostBinding('class.x-resizable-disabled') get getDisabled() {\r\n    return !this.xResizable;\r\n  }\r\n  document = inject(DOCUMENT);\r\n  ele!: HTMLElement;\r\n  cornerPositions: XResizablePosition[] = ['top-start', 'top-end', 'bottom-start', 'bottom-end'];\r\n  allPositions: XResizablePosition[] = ['left', 'right', 'top', 'bottom', ...this.cornerPositions];\r\n  positions: XResizablePosition[] = [];\r\n  direction?: XResizablePosition | null;\r\n  newBox = { clientWidth: 0, clientHeight: 0, offsetLeft: 0, offsetTop: 0 };\r\n  mouseUpSub?: Subscription;\r\n\r\n  minWidth?: number;\r\n  maxWidth?: number;\r\n  minHeight?: number;\r\n  maxHeight?: number;\r\n\r\n  positionNodes: { [key: string]: HTMLElement } = {};\r\n  activatingNodes: HTMLElement[] = [];\r\n\r\n  firstLoaded = true;\r\n\r\n  constructor(private renderer: Renderer2, private elementRef: ElementRef) {\r\n    super();\r\n    this.ele = this.elementRef.nativeElement;\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.setMapClass();\r\n  }\r\n\r\n  ngAfterViewInit() {\r\n    this.setPosition();\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.destroySubscription();\r\n  }\r\n\r\n  ngOnChanges(changes: SimpleChanges) {\r\n    const { xResizable } = changes;\r\n    XIsChange(xResizable) && this.setPosition();\r\n  }\r\n\r\n  @HostListener('mousedown', ['$event'])\r\n  @HostListener('touchstart', ['$event'])\r\n  mousedown(event: MouseEvent | TouchEvent) {\r\n    if (!this.xResizable) return;\r\n    const classList = (event.target as HTMLElement).classList;\r\n    let direction: XResizablePosition | null = null;\r\n    for (let pos of this.allPositions) {\r\n      if (classList.contains(`x-resizable-${pos}`)) {\r\n        direction = pos;\r\n        break;\r\n      }\r\n    }\r\n    if (!direction) return;\r\n\r\n    const evt = event.type.startsWith('touch') ? (event as TouchEvent).targetTouches[0] : (event as MouseEvent);\r\n    const { clientWidth, clientHeight, offsetLeft, offsetTop } = this.ele;\r\n    const { screenX, screenY } = evt;\r\n    const isTouchEvent = event.type.startsWith('touch');\r\n    const moveEvent = isTouchEvent ? 'touchmove' : 'mousemove';\r\n    const upEvent = isTouchEvent ? 'touchend' : 'mouseup';\r\n\r\n    this.setActivatingNodes(direction);\r\n    this.initResize(event, direction);\r\n\r\n    const mouseup = fromEvent(this.document, upEvent);\r\n    this.mouseUpSub = mouseup.subscribe((ev) => {\r\n      this.mouseup(ev as MouseEvent | TouchEvent);\r\n    });\r\n    const mouseMoveSub = fromEvent(document, moveEvent)\r\n      .pipe(takeUntil(mouseup))\r\n      .subscribe((ev) => this.move(ev as MouseEvent | TouchEvent, clientWidth, clientHeight, offsetTop, offsetLeft, screenX, screenY));\r\n\r\n    this.mouseUpSub.add(mouseMoveSub);\r\n  }\r\n\r\n  setMapClass() {\r\n    this.renderer.addClass(this.ele, XResizablePrefix);\r\n  }\r\n\r\n  setPosition() {\r\n    if (!this.xResizable || !this.firstLoaded) return;\r\n    let positions: XResizablePosition[] = [];\r\n    if (XIsString(this.position)) {\r\n      positions.push(this.position as XResizablePosition);\r\n    } else if (XIsArray(this.position)) {\r\n      positions = this.position as XResizablePosition[];\r\n    }\r\n\r\n    if (positions.includes('all')) {\r\n      this.positions = this.allPositions;\r\n    } else {\r\n      this.positions = positions;\r\n    }\r\n    this.createNode(...this.positions);\r\n\r\n    const computedStyle = XComputed(this.ele);\r\n    setTimeout(() => {\r\n      this.minWidth = parseFloat(computedStyle.minWidth);\r\n      this.maxWidth = parseFloat(computedStyle.maxWidth);\r\n      this.minHeight = parseFloat(computedStyle.minHeight);\r\n      this.maxHeight = parseFloat(computedStyle.maxHeight);\r\n      this.firstLoaded = false;\r\n    });\r\n  }\r\n\r\n  setActivatingNodes(direction: XResizablePosition) {\r\n    if (!this.positions.includes(direction)) return;\r\n    const addActivatingNode = (...direction: XResizablePosition[]) => {\r\n      for (let item of direction) {\r\n        const nd = this.positionNodes[item];\r\n        const isNd = this.activatingNodes.includes(nd);\r\n        if (!nd || isNd) continue;\r\n        this.renderer.addClass(nd, 'x-resizable-activating');\r\n        this.activatingNodes.push(nd);\r\n      }\r\n    };\r\n    if (this.cornerPositions.includes(direction)) {\r\n      switch (direction) {\r\n        case 'bottom-end':\r\n          addActivatingNode('bottom', 'right');\r\n          break;\r\n        case 'top-end':\r\n          addActivatingNode('top', 'right');\r\n          break;\r\n        case 'bottom-start':\r\n          addActivatingNode('bottom', 'left');\r\n          break;\r\n        case 'top-start':\r\n          addActivatingNode('top', 'left');\r\n          break;\r\n      }\r\n    }\r\n    addActivatingNode(direction);\r\n  }\r\n\r\n  createNode(...classes: XResizablePosition[]) {\r\n    for (let cla of classes) {\r\n      const pos = this.renderer.createElement('div');\r\n      this.renderer.addClass(pos, `x-resizable-${cla}`);\r\n      this.renderer.appendChild(this.ele, pos);\r\n      this.positionNodes[cla] = pos;\r\n    }\r\n  }\r\n\r\n  initResize(event: MouseEvent | TouchEvent, direction: XResizablePosition) {\r\n    this.direction = direction;\r\n    this.renderer.addClass(this.ele, `x-resizable-resizing`);\r\n    let { clientWidth, clientHeight, offsetLeft, offsetTop } = this.ele;\r\n    this.newBox = { clientWidth, clientHeight, offsetLeft, offsetTop };\r\n    event.stopPropagation();\r\n    this.resizeBegin.emit();\r\n  }\r\n\r\n  mouseup(event: MouseEvent | TouchEvent) {\r\n    this.endResize(event);\r\n    this.destroySubscription();\r\n  }\r\n\r\n  endResize(event: MouseEvent | TouchEvent) {\r\n    const evt = event.type.startsWith('touch') ? (event as TouchEvent).targetTouches[0] : (event as MouseEvent);\r\n    this.direction = null;\r\n    this.renderer.removeClass(this.ele, `x-resizable-resizing`);\r\n    for (const node of this.activatingNodes) {\r\n      this.renderer.removeClass(node, 'x-resizable-activating');\r\n    }\r\n    this.activatingNodes = [];\r\n    this.resizeEnd.emit({ event: evt, ...this.newBox });\r\n  }\r\n\r\n  move(event: MouseEvent | TouchEvent, width: number, height: number, top: number, left: number, screenX: number, screenY: number) {\r\n    const evt = event.type.startsWith('touch') ? (event as TouchEvent).targetTouches[0] : (event as MouseEvent);\r\n    const movementX = evt.screenX - screenX;\r\n    const movementY = evt.screenY - screenY;\r\n\r\n    this.newBox = {\r\n      clientWidth: width - (['bottom-start', 'left', 'top-start'].includes(this.direction as string) ? movementX : -movementX),\r\n      clientHeight: height - (['top-start', 'top', 'top-end'].includes(this.direction as string) ? movementY : -movementY),\r\n      offsetLeft: left + movementX,\r\n      offsetTop: top + movementY\r\n    };\r\n\r\n    const box = {\r\n      ...this.newBox,\r\n      offsetLeft: this.newBox.offsetLeft - Number(this.offsetLeft),\r\n      offsetTop: this.newBox.offsetTop - Number(this.offsetTop)\r\n    };\r\n\r\n    this.resizeBox(box);\r\n\r\n    this.resizing.emit({ ...this.newBox, event: evt, direction: this.direction });\r\n  }\r\n\r\n  resizeBox(box: { clientWidth: number; clientHeight: number; offsetLeft: number; offsetTop: number }) {\r\n    if (this.ghost) return;\r\n    const overMinWidth = !this.minWidth || box.clientWidth >= this.minWidth;\r\n    const underMaxWidth = !this.maxWidth || box.clientWidth <= this.maxWidth;\r\n    const overMinHeight = !this.minHeight || box.clientHeight >= this.minHeight;\r\n    const underMaxHeight = !this.maxHeight || box.clientHeight <= this.maxHeight;\r\n\r\n    switch (this.direction) {\r\n      case 'right':\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        break;\r\n      case 'top-end':\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n      case 'bottom-end':\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n      case 'bottom-start':\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n      case 'left':\r\n        console.log(this.minWidth);\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        break;\r\n      case 'top-start':\r\n        if (overMinWidth && underMaxWidth) {\r\n          this.renderer.setStyle(this.ele, 'left', `${box.offsetLeft}px`);\r\n          this.renderer.setStyle(this.ele, 'width', `${box.clientWidth}px`);\r\n        }\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n      case 'top':\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'top', `${box.offsetTop}px`);\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n      case 'bottom':\r\n        if (overMinHeight && underMaxHeight) {\r\n          this.renderer.setStyle(this.ele, 'height', `${box.clientHeight}px`);\r\n        }\r\n        break;\r\n    }\r\n  }\r\n\r\n  private destroySubscription() {\r\n    if (this.mouseUpSub) {\r\n      this.mouseUpSub.unsubscribe();\r\n      this.mouseUpSub = undefined;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/resizable/resizable.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { XResizableDirective } from './resizable.directive';
+import * as i0 from "@angular/core";
+class XResizableModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: XResizableModule, declarations: [XResizableDirective], imports: [CommonModule], exports: [XResizableDirective] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableModule, imports: [CommonModule] }); }
+}
+export { XResizableModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [XResizableDirective],
+                    exports: [XResizableDirective],
+                    imports: [CommonModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXphYmxlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3Jlc2l6YWJsZS9yZXNpemFibGUubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQUU1RCxNQUthLGdCQUFnQjtpSUFBaEIsZ0JBQWdCO2tJQUFoQixnQkFBZ0IsaUJBSlosbUJBQW1CLGFBRXhCLFlBQVksYUFEWixtQkFBbUI7a0lBR2xCLGdCQUFnQixZQUZqQixZQUFZOztTQUVYLGdCQUFnQjsyRkFBaEIsZ0JBQWdCO2tCQUw1QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLG1CQUFtQixDQUFDO29CQUNuQyxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztvQkFDOUIsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO2lCQUN4QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IFhSZXNpemFibGVEaXJlY3RpdmUgfSBmcm9tICcuL3Jlc2l6YWJsZS5kaXJlY3RpdmUnO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICBkZWNsYXJhdGlvbnM6IFtYUmVzaXphYmxlRGlyZWN0aXZlXSxcclxuICBleHBvcnRzOiBbWFJlc2l6YWJsZURpcmVjdGl2ZV0sXHJcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV1cclxufSlcclxuZXhwb3J0IGNsYXNzIFhSZXNpemFibGVNb2R1bGUge31cclxuIl19

package/esm2022/resizable/resizable.property.mjs

@@ -0,0 +1,95 @@
+import { __decorate } from "tslib";
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { XInputBoolean, XInputNumber, XProperty } from '@ng-nest/ui/core';
+import * as i0 from "@angular/core";
+/**
+ * Resizable 指令名称
+ * @selector x-resizable
+ * @decorator Directive
+ */
+export const XResizablePrefix = 'x-resizable';
+// const X_CONFIG_NAME = 'resizable';
+/**
+ * Resizable Property
+ */
+class XResizableProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 启用调整尺寸大小
+         * @en_US Enable adjustment size size
+         */
+        this.xResizable = true;
+        /**
+         * @zh_CN 调整方位
+         * @en_US Adjust the orientation
+         */
+        this.position = 'all';
+        /**
+         * @zh_CN 手动调整，通过回调的数值自行调整
+         * @en_US Manual adjustment, adjustment of the number of callbacks
+         */
+        this.ghost = false;
+        /**
+         * @zh_CN 偏移屏幕左边
+         * @en_US Distance on the left side
+         */
+        this.offsetLeft = 0;
+        /**
+         * @zh_CN 偏移屏幕顶部
+         * @en_US Distance to the top of the screen
+         */
+        this.offsetTop = 0;
+        /**
+         * @zh_CN 开始调整
+         * @en_US Adjust the orientation
+         */
+        this.resizeBegin = new EventEmitter();
+        /**
+         * @zh_CN 调整中
+         * @en_US Adjust the orientation
+         */
+        this.resizing = new EventEmitter();
+        /**
+         * @zh_CN 调整结束
+         * @en_US Adjust the orientation
+         */
+        this.resizeEnd = new EventEmitter();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableProperty, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: XResizableProperty, selector: "[xResizable]", inputs: { xResizable: "xResizable", position: "position", ghost: "ghost", offsetLeft: "offsetLeft", offsetTop: "offsetTop" }, outputs: { resizeBegin: "resizeBegin", resizing: "resizing", resizeEnd: "resizeEnd" }, usesInheritance: true, ngImport: i0 }); }
+}
+__decorate([
+    XInputBoolean()
+], XResizableProperty.prototype, "xResizable", void 0);
+__decorate([
+    XInputBoolean()
+], XResizableProperty.prototype, "ghost", void 0);
+__decorate([
+    XInputNumber()
+], XResizableProperty.prototype, "offsetLeft", void 0);
+__decorate([
+    XInputNumber()
+], XResizableProperty.prototype, "offsetTop", void 0);
+export { XResizableProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResizableProperty, decorators: [{
+            type: Directive,
+            args: [{ selector: '[xResizable]' }]
+        }], propDecorators: { xResizable: [{
+                type: Input
+            }], position: [{
+                type: Input
+            }], ghost: [{
+                type: Input
+            }], offsetLeft: [{
+                type: Input
+            }], offsetTop: [{
+                type: Input
+            }], resizeBegin: [{
+                type: Output
+            }], resizing: [{
+                type: Output
+            }], resizeEnd: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/result/ng-nest-ui-result.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctbmVzdC11aS1yZXN1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvbmctbmVzdC91aS9yZXN1bHQvbmctbmVzdC11aS1yZXN1bHQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/result/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './result.component';
+export * from './result.module';
+export * from './result.property';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3Jlc3VsdC9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yZXN1bHQuY29tcG9uZW50JztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXN1bHQubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXN1bHQucHJvcGVydHknO1xyXG4iXX0=

package/esm2022/result/result.component.mjs

@@ -0,0 +1,34 @@
+import { Component, ViewEncapsulation, ChangeDetectionStrategy } from '@angular/core';
+import { XResultPrefix, XResultProperty } from './result.property';
+import { XIsEmpty } from '@ng-nest/ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-nest/ui/core";
+import * as i2 from "@angular/common";
+import * as i3 from "@ng-nest/ui/icon";
+import * as i4 from "@ng-nest/ui/outlet";
+class XResultComponent extends XResultProperty {
+    get strIcon() {
+        return this.icon;
+    }
+    constructor(renderer, elementRef, cdr, configService) {
+        super();
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.configService = configService;
+    }
+    ngOnInit() {
+        this.setClassMap();
+    }
+    setClassMap() {
+        this.classMap[`${XResultPrefix}-${this.status}`] = !XIsEmpty(this.status);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.XConfigService }], target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XResultComponent, selector: "x-result", usesInheritance: true, ngImport: i0, template: "<div #result class=\"x-result\" [ngClass]=\"classMap\">\r\n  <div class=\"x-result-icon\">\r\n    <ng-container *ngIf=\"!icon; else iconTpl\" [ngSwitch]=\"status\">\r\n      <x-icon *ngSwitchCase=\"'success'\" type=\"adf-check-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'info'\" type=\"adf-info-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'warning'\" type=\"adf-warning\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'error'\" type=\"adf-close-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'403'\" type=\"fto-lock\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'404'\" type=\"fto-code\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'500'\" type=\"adf-close-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-template #iconTpl>\r\n      <ng-container *xOutlet=\"icon\">\r\n        <x-icon [type]=\"strIcon\"></x-icon>\r\n      </ng-container>\r\n    </ng-template>\r\n  </div>\r\n\r\n  <div class=\"x-result-title\">\r\n    <ng-container *xOutlet=\"title\">{{ title }}</ng-container>\r\n  </div>\r\n  <div class=\"x-result-subTitle\">\r\n    <ng-container *xOutlet=\"subTitle\">{{ subTitle }}</ng-container>\r\n  </div>\r\n  <div class=\"x-result-content\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n", styles: [".x-result{margin:0;padding:0;display:flex;flex-direction:column;align-items:center;padding:3rem 2rem}.x-result-icon{font-size:calc(var(--x-font-size) * 5);margin-bottom:var(--x-font-size-large)}.x-result-title{font-size:var(--x-font-size-large);line-height:calc(var(--x-font-size-large) * 1.5)}.x-result-subTitle{color:var(--x-text-400)}.x-result-content{margin-top:var(--x-font-size-large)}.x-result-success .x-result-icon{color:var(--x-success)}.x-result-info .x-result-icon{color:var(--x-info)}.x-result-warning .x-result-icon{color:var(--x-warning)}.x-result-error .x-result-icon{color:var(--x-danger)}.x-result-403 .x-result-icon,.x-result-404 .x-result-icon{color:var(--x-text-400)}.x-result-500 .x-result-icon{color:var(--x-danger)}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i2.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "component", type: i3.XIconComponent, selector: "x-icon" }, { kind: "directive", type: i4.XOutletDirective, selector: "[xOutlet]", inputs: ["xOutletContext", "xOutlet"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { XResultComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultComponent, decorators: [{
+            type: Component,
+            args: [{ selector: `${XResultPrefix}`, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div #result class=\"x-result\" [ngClass]=\"classMap\">\r\n  <div class=\"x-result-icon\">\r\n    <ng-container *ngIf=\"!icon; else iconTpl\" [ngSwitch]=\"status\">\r\n      <x-icon *ngSwitchCase=\"'success'\" type=\"adf-check-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'info'\" type=\"adf-info-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'warning'\" type=\"adf-warning\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'error'\" type=\"adf-close-circle\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'403'\" type=\"fto-lock\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'404'\" type=\"fto-code\"></x-icon>\r\n      <x-icon *ngSwitchCase=\"'500'\" type=\"adf-close-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-template #iconTpl>\r\n      <ng-container *xOutlet=\"icon\">\r\n        <x-icon [type]=\"strIcon\"></x-icon>\r\n      </ng-container>\r\n    </ng-template>\r\n  </div>\r\n\r\n  <div class=\"x-result-title\">\r\n    <ng-container *xOutlet=\"title\">{{ title }}</ng-container>\r\n  </div>\r\n  <div class=\"x-result-subTitle\">\r\n    <ng-container *xOutlet=\"subTitle\">{{ subTitle }}</ng-container>\r\n  </div>\r\n  <div class=\"x-result-content\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n", styles: [".x-result{margin:0;padding:0;display:flex;flex-direction:column;align-items:center;padding:3rem 2rem}.x-result-icon{font-size:calc(var(--x-font-size) * 5);margin-bottom:var(--x-font-size-large)}.x-result-title{font-size:var(--x-font-size-large);line-height:calc(var(--x-font-size-large) * 1.5)}.x-result-subTitle{color:var(--x-text-400)}.x-result-content{margin-top:var(--x-font-size-large)}.x-result-success .x-result-icon{color:var(--x-success)}.x-result-info .x-result-icon{color:var(--x-info)}.x-result-warning .x-result-icon{color:var(--x-warning)}.x-result-error .x-result-icon{color:var(--x-danger)}.x-result-403 .x-result-icon,.x-result-404 .x-result-icon{color:var(--x-text-400)}.x-result-500 .x-result-icon{color:var(--x-danger)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.XConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/result/result.module.mjs

@@ -0,0 +1,22 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { XResultComponent } from './result.component';
+import { XIconModule } from '@ng-nest/ui/icon';
+import { XOutletModule } from '@ng-nest/ui/outlet';
+import { XResultProperty } from './result.property';
+import * as i0 from "@angular/core";
+class XResultModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: XResultModule, declarations: [XResultComponent, XResultProperty], imports: [CommonModule, XIconModule, XOutletModule], exports: [XResultComponent] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultModule, imports: [CommonModule, XIconModule, XOutletModule] }); }
+}
+export { XResultModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [XResultComponent, XResultProperty],
+                    exports: [XResultComponent],
+                    imports: [CommonModule, XIconModule, XOutletModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzdWx0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3Jlc3VsdC9yZXN1bHQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUMvQyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG1CQUFtQixDQUFDOztBQUVwRCxNQUthLGFBQWE7aUlBQWIsYUFBYTtrSUFBYixhQUFhLGlCQUpULGdCQUFnQixFQUFFLGVBQWUsYUFFdEMsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhLGFBRHhDLGdCQUFnQjtrSUFHZixhQUFhLFlBRmQsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhOztTQUV2QyxhQUFhOzJGQUFiLGFBQWE7a0JBTHpCLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFLENBQUMsZ0JBQWdCLEVBQUUsZUFBZSxDQUFDO29CQUNqRCxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQztvQkFDM0IsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxhQUFhLENBQUM7aUJBQ3BEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHsgWFJlc3VsdENvbXBvbmVudCB9IGZyb20gJy4vcmVzdWx0LmNvbXBvbmVudCc7XHJcbmltcG9ydCB7IFhJY29uTW9kdWxlIH0gZnJvbSAnQG5nLW5lc3QvdWkvaWNvbic7XHJcbmltcG9ydCB7IFhPdXRsZXRNb2R1bGUgfSBmcm9tICdAbmctbmVzdC91aS9vdXRsZXQnO1xyXG5pbXBvcnQgeyBYUmVzdWx0UHJvcGVydHkgfSBmcm9tICcuL3Jlc3VsdC5wcm9wZXJ0eSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW1hSZXN1bHRDb21wb25lbnQsIFhSZXN1bHRQcm9wZXJ0eV0sXHJcbiAgZXhwb3J0czogW1hSZXN1bHRDb21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIFhJY29uTW9kdWxlLCBYT3V0bGV0TW9kdWxlXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgWFJlc3VsdE1vZHVsZSB7fVxyXG4iXX0=

package/esm2022/result/result.property.mjs

@@ -0,0 +1,38 @@
+import { XProperty } from '@ng-nest/ui/core';
+import { Input, Component } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Result
+ * @selector x-result
+ * @decorator component
+ */
+export const XResultPrefix = 'x-result';
+/**
+ * Result Property
+ */
+class XResultProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 状态
+         * @en_US Status
+         */
+        this.status = 'info';
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultProperty, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    /** @nocollapse */ static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: XResultProperty, selector: "x-result-property", inputs: { status: "status", title: "title", icon: "icon", subTitle: "subTitle" }, usesInheritance: true, ngImport: i0, template: '', isInline: true }); }
+}
+export { XResultProperty };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: XResultProperty, decorators: [{
+            type: Component,
+            args: [{ selector: `${XResultPrefix}-property`, template: '' }]
+        }], propDecorators: { status: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], subTitle: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/ripple/ng-nest-ui-ripple.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctbmVzdC11aS1yaXBwbGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWIvbmctbmVzdC91aS9yaXBwbGUvbmctbmVzdC11aS1yaXBwbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/ripple/public-api.mjs

@@ -0,0 +1,4 @@
+export * from './ripple.directive';
+export * from './ripple.module';
+export * from './ripple.property';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3JpcHBsZS9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG1CQUFtQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9yaXBwbGUuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yaXBwbGUubW9kdWxlJztcclxuZXhwb3J0ICogZnJvbSAnLi9yaXBwbGUucHJvcGVydHknO1xyXG4iXX0=