@alauda-fe/dynamic-plugin-shared 0.0.1-alpha.0

package/esm2022/directives/effect-directive/event.directive.mjs

@@ -0,0 +1,129 @@
+import { __decorate, __metadata } from "tslib";
+import { booleanAttribute, Directive, HostListener, Input, } from '@angular/core';
+import { isBoolean } from 'lodash-es';
+import { ValueHook } from '../../utils';
+import * as i0 from "@angular/core";
+export var PreventHandler;
+(function (PreventHandler) {
+    PreventHandler["Contextmenu"] = "contextmenu";
+    PreventHandler["Paste"] = "paste";
+    PreventHandler["Cut"] = "cut";
+    PreventHandler["Copy"] = "copy";
+})(PreventHandler || (PreventHandler = {}));
+const handleEvent = (event, enable) => enable && event.preventDefault();
+/**
+ * 阻止点击事件
+ */
+export class PreventDirective {
+    constructor() {
+        this.prevent = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: PreventDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: PreventDirective, isStandalone: true, selector: "[prevent]", inputs: { prevent: "prevent" }, host: { attributes: { "click": "prevent && $event.preventDefault()" } }, ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(isBoolean),
+    __metadata("design:type", Object)
+], PreventDirective.prototype, "prevent", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: PreventDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[prevent]',
+                    host: {
+                        click: 'prevent && $event.preventDefault()',
+                    },
+                    standalone: true,
+                }]
+        }], propDecorators: { prevent: [{
+                type: Input
+            }] } });
+/**
+ * 阻止冒泡事件
+ */
+export class StopDirective {
+    constructor() {
+        this.stop = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: StopDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: StopDirective, isStandalone: true, selector: "[stop]", inputs: { stop: "stop" }, host: { attributes: { "click": "stop && $event.stopPropagation()" } }, ngImport: i0 }); }
+}
+__decorate([
+    ValueHook(isBoolean),
+    __metadata("design:type", Object)
+], StopDirective.prototype, "stop", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: StopDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[stop]',
+                    host: {
+                        click: 'stop && $event.stopPropagation()',
+                    },
+                    standalone: true,
+                }]
+        }], propDecorators: { stop: [{
+                type: Input
+            }] } });
+/**
+ * 阻止剪切板（拷贝、粘贴、剪切、右键菜单）等事件
+ *
+ * @example
+ *
+ * 阻止全部:
+ * ```
+ * <input aui-input aclPreventEvent>
+ * ```
+ * 自定义:
+ * ```
+ * <input aui-input [aclPreventEvent]="{copy: true, paste: true}">
+ * ```
+ */
+export class PreventClipboardDirective {
+    constructor() {
+        this.preventClipboardEvent = true;
+    }
+    isPreventEvent(action) {
+        if (typeof this.preventClipboardEvent === 'object') {
+            return !!this.preventClipboardEvent[action];
+        }
+        return booleanAttribute(this.preventClipboardEvent);
+    }
+    onContextmenu(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Contextmenu));
+    }
+    onCut(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Cut));
+    }
+    onPaste(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Paste));
+    }
+    onCopy(event) {
+        handleEvent(event, this.isPreventEvent(PreventHandler.Copy));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: PreventClipboardDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: PreventClipboardDirective, isStandalone: true, selector: "input[aclPreventClipboardEvent]", inputs: { preventClipboardEvent: ["aclPreventClipboardEvent", "preventClipboardEvent"] }, host: { listeners: { "contextmenu": "onContextmenu($event)", "cut": "onCut($event)", "paste": "onPaste($event)", "copy": "onCopy($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: PreventClipboardDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[aclPreventClipboardEvent]',
+                    standalone: true,
+                }]
+        }], propDecorators: { preventClipboardEvent: [{
+                type: Input,
+                args: ['aclPreventClipboardEvent']
+            }], onContextmenu: [{
+                type: HostListener,
+                args: ['contextmenu', ['$event']]
+            }], onCut: [{
+                type: HostListener,
+                args: ['cut', ['$event']]
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }], onCopy: [{
+                type: HostListener,
+                args: ['copy', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/effect-directive/index.mjs

@@ -0,0 +1,21 @@
+import { E2eAttributeBindingDirective } from './e2e-attribute-binding.directive';
+import { PreventDirective, StopDirective } from './event.directive';
+import { MaxValidatorDirective, MinValidatorDirective, } from './min-max.directive';
+import { TrimDirective } from './trim.directive';
+import { ValidatorsDirective } from './validators.directive';
+export const EFFECT_DIRECTIVE_MODULE = [
+    E2eAttributeBindingDirective,
+    MaxValidatorDirective,
+    MinValidatorDirective,
+    TrimDirective,
+    ValidatorsDirective,
+    PreventDirective,
+    StopDirective,
+];
+export * from './coerce-number.directive';
+export * from './e2e-attribute-binding.directive';
+export * from './event.directive';
+export * from './min-max.directive';
+export * from './trim.directive';
+export * from './validators.directive';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/effect-directive/min-max.directive.mjs

@@ -0,0 +1,107 @@
+import { Directive, HostBinding, Input, forwardRef, } from '@angular/core';
+import { NG_VALIDATORS, Validators, } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Angular form directives for min/max.
+ */
+export class MaxValidatorDirective {
+    get maxValue() {
+        return this.max || this.max === 0 ? this.max : null;
+    }
+    ngOnChanges(changes) {
+        if ('max' in changes) {
+            this._createValidator();
+            if (this._onChange) {
+                this._onChange();
+            }
+        }
+    }
+    validate(c) {
+        return this.max == null ? null : this._validator(c);
+    }
+    registerOnValidatorChange(fn) {
+        this._onChange = fn;
+    }
+    _createValidator() {
+        this._validator = Validators.max(typeof this.max === 'number' ? this.max : parseFloat(this.max));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MaxValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MaxValidatorDirective, isStandalone: true, selector: "[max][formControlName],[max][formControl],[max][ngModel]", inputs: { max: "max" }, host: { properties: { "attr.max": "this.maxValue" } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => MaxValidatorDirective),
+                multi: true,
+            },
+        ], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MaxValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[max][formControlName],[max][formControl],[max][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => MaxValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { max: [{
+                type: Input
+            }], maxValue: [{
+                type: HostBinding,
+                args: ['attr.max']
+            }] } });
+export class MinValidatorDirective {
+    get maxValue() {
+        return this.min || this.min === 0 ? this.min : null;
+    }
+    ngOnChanges(changes) {
+        if ('min' in changes) {
+            this._createValidator();
+            if (this._onChange) {
+                this._onChange();
+            }
+        }
+    }
+    validate(c) {
+        return this.min == null ? null : this._validator(c);
+    }
+    registerOnValidatorChange(fn) {
+        this._onChange = fn;
+    }
+    _createValidator() {
+        this._validator = Validators.min(typeof this.min === 'number' ? this.min : parseFloat(this.min));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MinValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: MinValidatorDirective, isStandalone: true, selector: "[min][formControlName],[min][formControl],[min][ngModel]", inputs: { min: "min" }, host: { properties: { "attr.min": "this.maxValue" } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => MinValidatorDirective),
+                multi: true,
+            },
+        ], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: MinValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[min][formControlName],[min][formControl],[min][ngModel]',
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => MinValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { maxValue: [{
+                type: HostBinding,
+                args: ['attr.min']
+            }], min: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/effect-directive/trim.directive.mjs

@@ -0,0 +1,40 @@
+import { Directive, forwardRef } from '@angular/core';
+import { DefaultValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+export class TrimDirective extends DefaultValueAccessor {
+    _handleInput(value) {
+        if (value != null) {
+            this.onChange(value.trim());
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TrimDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: TrimDirective, isStandalone: true, selector: "input[trim],textarea[trim]]", host: { listeners: { "input": "$any(this)._handleInput($event.target.value)", "blur": "onTouched()", "compositionstart": "$any(this)._compositionStart()", "compositionend": "$any(this)._compositionEnd($event.target.value)" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => TrimDirective),
+                multi: true,
+            },
+        ], usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TrimDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: 'input[trim],textarea[trim]]',
+                    host: {
+                        '(input)': '$any(this)._handleInput($event.target.value)',
+                        '(blur)': 'onTouched()',
+                        '(compositionstart)': '$any(this)._compositionStart()',
+                        '(compositionend)': '$any(this)._compositionEnd($event.target.value)',
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => TrimDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/effect-directive/validators.directive.mjs

@@ -0,0 +1,43 @@
+import { Directive } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+function getSelector(validator) {
+    return `[ngModel][${validator}],[formControl][${validator}],[formControlName][${validator}]`;
+}
+export class ValidatorsDirective {
+    constructor(ngControl) {
+        this.ngControl = ngControl;
+    }
+    ngAfterViewInit() {
+        this.validate();
+    }
+    ngOnDestroy() {
+        this.validate();
+    }
+    validate() {
+        this.ngControl.control?.updateValueAndValidity();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ValidatorsDirective, deps: [{ token: i1.NgControl }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: ValidatorsDirective, isStandalone: true, selector: "[ngModel][required],[formControl][required],[formControlName][required],[ngModel][pattern],[formControl][pattern],[formControlName][pattern],[ngModel][min],[formControl][min],[formControlName][min],[ngModel][max],[formControl][max],[formControlName][max],[ngModel][minlength],[formControl][minlength],[formControlName][minlength],[ngModel][maxlength],[formControl][maxlength],[formControlName][maxlength],[ngModel][email],[formControl][email],[formControlName][email]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ValidatorsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: getSelector('required') +
+                        ',' +
+                        getSelector('pattern') +
+                        ',' +
+                        getSelector('min') +
+                        ',' +
+                        getSelector('max') +
+                        ',' +
+                        getSelector('minlength') +
+                        ',' +
+                        getSelector('maxlength') +
+                        ',' +
+                        getSelector('email'),
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i1.NgControl }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/feature-gate.directive.mjs

@@ -0,0 +1,90 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { FeatureGateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { ChangeDetectorRef, Directive, Input, TemplateRef, ViewContainerRef, 
+// cspell: disable-next-line
+ɵstringify as stringify, } from '@angular/core';
+import { distinctUntilChanged } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/dynamic-plugin-sdk";
+/**
+ * @example
+ * ```
+ * <ng-container *aclFeatureGate="gate-name"></ng-container>
+ * ```
+ */
+export class FeatureGateDirective {
+    set then(templateRef) {
+        assertTemplate('aclFeatureGateThen', templateRef);
+        this.thenTemplateRef = templateRef;
+    }
+    set else(templateRef) {
+        assertTemplate('aclVersionGateElse', templateRef);
+        this.elseTemplateRef = templateRef;
+    }
+    constructor(container, featureGate, crd, templateRef) {
+        this.container = container;
+        this.featureGate = featureGate;
+        this.crd = crd;
+        this.featureName = null;
+        this.cluster = null;
+        this.negate = false;
+        this.thenTemplateRef = null;
+        this.elseTemplateRef = null;
+        this.subscription = null;
+        this.thenTemplateRef = templateRef;
+    }
+    ngOnInit() {
+        if (!this.featureName) {
+            this.container.createEmbeddedView(this.thenTemplateRef);
+            return;
+        }
+        this.subscription = this.featureGate[this.negate ? 'isNegateEnabled' : 'isEnabled'](this.featureName, this.cluster)
+            .pipe(distinctUntilChanged())
+            .subscribe(enabled => {
+            this.container.clear();
+            if (enabled) {
+                this.container.createEmbeddedView(this.thenTemplateRef);
+            }
+            else if (this.elseTemplateRef) {
+                this.container.createEmbeddedView(this.elseTemplateRef);
+            }
+            this.crd.markForCheck();
+        });
+    }
+    ngOnDestroy() {
+        if (this.subscription) {
+            this.subscription.unsubscribe();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FeatureGateDirective, deps: [{ token: i0.ViewContainerRef }, { token: i1.FeatureGateService }, { token: i0.ChangeDetectorRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: FeatureGateDirective, isStandalone: true, selector: "[aclFeatureGate]", inputs: { featureName: ["aclFeatureGate", "featureName"], cluster: ["aclFeatureGateCluster", "cluster"], negate: ["aclFeatureGateNegate", "negate"], then: ["aclFeatureGateThen", "then"], else: ["aclFeatureGateElse", "else"] }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FeatureGateDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[aclFeatureGate]', standalone: true }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }, { type: i1.FeatureGateService }, { type: i0.ChangeDetectorRef }, { type: i0.TemplateRef }], propDecorators: { featureName: [{
+                type: Input,
+                args: ['aclFeatureGate']
+            }], cluster: [{
+                type: Input,
+                args: ['aclFeatureGateCluster']
+            }], negate: [{
+                type: Input,
+                args: ['aclFeatureGateNegate']
+            }], then: [{
+                type: Input,
+                args: ['aclFeatureGateThen']
+            }], else: [{
+                type: Input,
+                args: ['aclFeatureGateElse']
+            }] } });
+function assertTemplate(property, templateRef) {
+    const isTemplateRefOrNull = !!(!templateRef || templateRef.createEmbeddedView);
+    if (!isTemplateRefOrNull) {
+        throw new Error(`${property} must be a TemplateRef, but received '${stringify(templateRef)}'.`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/index.mjs

@@ -0,0 +1,13 @@
+export * from './disabled.directive';
+export * from './feature-gate.directive';
+export * from './last-form-item.directive';
+export * from './readonly-field.directive';
+export * from './resize.directive';
+export * from './scroll-to-first-invalid.directive';
+export * from './scroll-border-observer.directive';
+export * from './click-outside.directive';
+export * from './declare.directive';
+export { AuiCodeEditorHelperDirective } from './aui-code-editor.directive';
+export * from './value-trace.directive';
+export * from './effect-directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxPQUFPLEVBQUUsNEJBQTRCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQztBQUUzRSxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Rpc2FibGVkLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtZ2F0ZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9sYXN0LWZvcm0taXRlbS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZWFkb25seS1maWVsZC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNpemUuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLXRvLWZpcnN0LWludmFsaWQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vc2Nyb2xsLWJvcmRlci1vYnNlcnZlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9jbGljay1vdXRzaWRlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2RlY2xhcmUuZGlyZWN0aXZlJztcbmV4cG9ydCB7IEF1aUNvZGVFZGl0b3JIZWxwZXJEaXJlY3RpdmUgfSBmcm9tICcuL2F1aS1jb2RlLWVkaXRvci5kaXJlY3RpdmUnO1xuXG5leHBvcnQgKiBmcm9tICcuL3ZhbHVlLXRyYWNlLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2VmZmVjdC1kaXJlY3RpdmUnO1xuIl19

package/esm2022/directives/last-form-item.directive.mjs

@@ -0,0 +1,18 @@
+import { Directive, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FormItemMarginEffectDirective {
+    constructor(el) {
+        this.el = el;
+        this.el.nativeElement.style.display = 'block';
+        this.el.nativeElement.style.marginBottom = '-16px';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FormItemMarginEffectDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: FormItemMarginEffectDirective, selector: "[aclFormItemEffect]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: FormItemMarginEffectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclFormItemEffect]',
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGFzdC1mb3JtLWl0ZW0uZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2RpcmVjdGl2ZXMvbGFzdC1mb3JtLWl0ZW0uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUt0RCxNQUFNLE9BQU8sNkJBQTZCO0lBQ3hDLFlBQTZCLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBQ3pDLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQzlDLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDLEtBQUssQ0FBQyxZQUFZLEdBQUcsT0FBTyxDQUFDO0lBQ3JELENBQUM7OEdBSlUsNkJBQTZCO2tHQUE3Qiw2QkFBNkI7OzJGQUE3Qiw2QkFBNkI7a0JBSHpDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHFCQUFxQjtpQkFDaEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW2FjbEZvcm1JdGVtRWZmZWN0XScsXG59KVxuZXhwb3J0IGNsYXNzIEZvcm1JdGVtTWFyZ2luRWZmZWN0RGlyZWN0aXZlIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSBlbDogRWxlbWVudFJlZikge1xuICAgIHRoaXMuZWwubmF0aXZlRWxlbWVudC5zdHlsZS5kaXNwbGF5ID0gJ2Jsb2NrJztcbiAgICB0aGlzLmVsLm5hdGl2ZUVsZW1lbnQuc3R5bGUubWFyZ2luQm90dG9tID0gJy0xNnB4JztcbiAgfVxufVxuIl19