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

package/directives/effect-directive/event.directive.d.ts

@@ -0,0 +1,47 @@
+import * as i0 from "@angular/core";
+export declare enum PreventHandler {
+    Contextmenu = "contextmenu",
+    Paste = "paste",
+    Cut = "cut",
+    Copy = "copy"
+}
+/**
+ * 阻止点击事件
+ */
+export declare class PreventDirective {
+    prevent: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventDirective, "[prevent]", never, { "prevent": { "alias": "prevent"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * 阻止冒泡事件
+ */
+export declare class StopDirective {
+    stop: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<StopDirective, "[stop]", never, { "stop": { "alias": "stop"; "required": false; }; }, {}, never, never, true, never>;
+}
+/**
+ * 阻止剪切板（拷贝、粘贴、剪切、右键菜单）等事件
+ *
+ * @example
+ *
+ * 阻止全部:
+ * ```
+ * <input aui-input aclPreventEvent>
+ * ```
+ * 自定义:
+ * ```
+ * <input aui-input [aclPreventEvent]="{copy: true, paste: true}">
+ * ```
+ */
+export declare class PreventClipboardDirective {
+    preventClipboardEvent: boolean | '' | Partial<Record<PreventHandler, boolean>>;
+    private isPreventEvent;
+    onContextmenu(event: Event): void;
+    onCut(event: Event): void;
+    onPaste(event: Event): void;
+    onCopy(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventClipboardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PreventClipboardDirective, "input[aclPreventClipboardEvent]", never, { "preventClipboardEvent": { "alias": "aclPreventClipboardEvent"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/effect-directive/index.d.ts

@@ -0,0 +1,12 @@
+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 declare const EFFECT_DIRECTIVE_MODULE: readonly [typeof E2eAttributeBindingDirective, typeof MaxValidatorDirective, typeof MinValidatorDirective, typeof TrimDirective, typeof ValidatorsDirective, typeof PreventDirective, typeof 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';

package/directives/effect-directive/min-max.directive.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { AbstractControl, ValidationErrors, Validator } from '@angular/forms';
+import * as i0 from "@angular/core";
+/**
+ * Angular form directives for min/max.
+ */
+export declare class MaxValidatorDirective implements Validator, OnChanges {
+    private _validator;
+    private _onChange;
+    max: string | number;
+    get maxValue(): string | number;
+    ngOnChanges(changes: SimpleChanges): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    private _createValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaxValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MaxValidatorDirective, "[max][formControlName],[max][formControl],[max][ngModel]", never, { "max": { "alias": "max"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class MinValidatorDirective implements Validator, OnChanges {
+    private _validator;
+    private _onChange;
+    get maxValue(): string | number;
+    min: string | number;
+    ngOnChanges(changes: SimpleChanges): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    registerOnValidatorChange(fn: () => void): void;
+    private _createValidator;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MinValidatorDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MinValidatorDirective, "[min][formControlName],[min][formControl],[min][ngModel]", never, { "min": { "alias": "min"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/effect-directive/trim.directive.d.ts

@@ -0,0 +1,7 @@
+import { DefaultValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class TrimDirective extends DefaultValueAccessor {
+    _handleInput(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrimDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TrimDirective, "input[trim],textarea[trim]]", never, {}, {}, never, never, true, never>;
+}

package/directives/effect-directive/validators.directive.d.ts

@@ -0,0 +1,12 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ValidatorsDirective implements AfterViewInit, OnDestroy {
+    private readonly ngControl;
+    constructor(ngControl: NgControl);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    validate(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ValidatorsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ValidatorsDirective, "[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]", never, {}, {}, never, never, true, never>;
+}

package/directives/feature-gate.directive.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { FeatureGateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { ChangeDetectorRef, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @example
+ * ```
+ * <ng-container *aclFeatureGate="gate-name"></ng-container>
+ * ```
+ */
+export declare class FeatureGateDirective implements OnInit, OnDestroy {
+    private readonly container;
+    private readonly featureGate;
+    private readonly crd;
+    featureName: string;
+    cluster: string;
+    negate: boolean;
+    set then(templateRef: TemplateRef<void>);
+    set else(templateRef: TemplateRef<void>);
+    private thenTemplateRef;
+    private elseTemplateRef;
+    private subscription;
+    constructor(container: ViewContainerRef, featureGate: FeatureGateService, crd: ChangeDetectorRef, templateRef: TemplateRef<void>);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FeatureGateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FeatureGateDirective, "[aclFeatureGate]", never, { "featureName": { "alias": "aclFeatureGate"; "required": false; }; "cluster": { "alias": "aclFeatureGateCluster"; "required": false; }; "negate": { "alias": "aclFeatureGateNegate"; "required": false; }; "then": { "alias": "aclFeatureGateThen"; "required": false; }; "else": { "alias": "aclFeatureGateElse"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/index.d.ts

@@ -0,0 +1,12 @@
+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';

package/directives/last-form-item.directive.d.ts

@@ -0,0 +1,8 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FormItemMarginEffectDirective {
+    private readonly el;
+    constructor(el: ElementRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemMarginEffectDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FormItemMarginEffectDirective, "[aclFormItemEffect]", never, {}, {}, never, never, false, never>;
+}

package/directives/readonly-field.directive.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { FormItemControlDirective } from '@alauda/ui';
+import { ComponentFactoryResolver, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class ReadonlyFieldDirective implements OnInit, OnDestroy {
+    private readonly control;
+    private readonly cfr;
+    private readonly viewContainerRef;
+    private readonly controlDirective;
+    aclReadonlyField: boolean;
+    aclReadonlyField$: Observable<boolean>;
+    hidden: boolean;
+    private isControlRequired;
+    private spanComponentRef;
+    private readonly templateContext;
+    private readonly destroy$;
+    template: TemplateRef<any>;
+    context: object;
+    get isHidden(): boolean;
+    constructor(control: NgControl, cfr: ComponentFactoryResolver, viewContainerRef: ViewContainerRef, controlDirective: FormItemControlDirective);
+    private setValue;
+    ngOnInit(): void;
+    private applyValidators;
+    private clearValidators;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReadonlyFieldDirective, [null, null, null, { optional: true; self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ReadonlyFieldDirective, "[aclReadonlyField]", never, { "aclReadonlyField": { "alias": "aclReadonlyField"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "template": { "alias": "aclReadonlyFieldTemplate"; "required": false; }; "context": { "alias": "aclReadonlyFieldTemplateContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+export declare class SpanComponent<T = unknown> {
+    data: T;
+    setData(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpanComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpanComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}

package/directives/resize.directive.d.ts

@@ -0,0 +1,17 @@
+import { AfterViewInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+export interface ResizeEvent {
+    width: number;
+    height: number;
+}
+export declare class ResizeDirective implements OnDestroy, AfterViewInit {
+    private readonly element;
+    resized: EventEmitter<ResizeEvent>;
+    private readonly destroy$$;
+    constructor(element: ElementRef);
+    ngAfterViewInit(): void;
+    private onResized;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeDirective, "[aclResize]", never, {}, { "resized": "resized"; }, never, never, true, never>;
+}

package/directives/scroll-border-observer.directive.d.ts

@@ -0,0 +1,23 @@
+import { EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+interface Option {
+    bottomDistance?: number;
+    topDistance?: number;
+}
+export declare class ScrollBorderObserverDirective implements OnInit, OnDestroy {
+    option: Option | '' | false | number;
+    scrollBorder: EventEmitter<"top" | "bottom">;
+    scrollBottomBorder: EventEmitter<any>;
+    scrollEl: HTMLElement | Window;
+    readonly destroy$$: Subject<void>;
+    private readonly scrollDispatcher;
+    private readonly viewContainerRef;
+    constructor(injector: Injector);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setupScroll;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollBorderObserverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollBorderObserverDirective, "[aclScrollBorderObserver]", never, { "option": { "alias": "aclScrollBorderObserver"; "required": false; }; }, { "scrollBorder": "scrollBorder"; "scrollBottomBorder": "scrollBottomBorder"; }, never, never, true, never>;
+}
+export {};

package/directives/scroll-to-first-invalid.directive.d.ts

@@ -0,0 +1,24 @@
+import { CdkScrollable } from '@angular/cdk/scrolling';
+import { ElementRef } from '@angular/core';
+import { ControlContainer } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class ScrollToFirstInvalidMarkerDirective {
+    aclScrollToFirstInvalidMarker: boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToFirstInvalidMarkerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollToFirstInvalidMarkerDirective, "[aclScrollToFirstInvalidMarker]", never, { "aclScrollToFirstInvalidMarker": { "alias": "aclScrollToFirstInvalidMarker"; "required": false; }; }, {}, never, never, false, never>;
+}
+export declare class ScrollToFirstInvalidDirective {
+    private readonly elRef;
+    private readonly controlContainer;
+    private readonly cdkScrollable;
+    labelOffset: number;
+    aclScrollToFirstInvalid: boolean | '';
+    get containerEl(): HTMLElement | (Window & typeof globalThis);
+    onSubmit(): void;
+    constructor(elRef: ElementRef<HTMLElement>, controlContainer: ControlContainer, cdkScrollable: CdkScrollable);
+    scrollToFirstInvalid(): void;
+    getFirstInvalidInput(): HTMLElement;
+    private getTopOffset;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollToFirstInvalidDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ScrollToFirstInvalidDirective, "[aclScrollToFirstInvalid]", never, { "labelOffset": { "alias": "labelOffset"; "required": false; }; "aclScrollToFirstInvalid": { "alias": "aclScrollToFirstInvalid"; "required": false; }; }, {}, never, never, true, never>;
+}

package/directives/value-trace.directive.d.ts

@@ -0,0 +1,27 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { Observable, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ *
+ * Usage:
+ * If you want to trace value with control.
+ * The difference between aclValueTrack and ngModelChange is that aclValueTrack carries the first value.
+ * So it is not for changes, but for value traces
+ * For compatibility and cover the deprecation of ngModelChange, we provide aclValueTrackSkipFirst option
+ * eg:
+ * <input formControlName="name" [aclValueTrack]="function()">
+ *
+ */
+export declare class ControlValueTraceDirective implements OnInit, OnDestroy {
+    private readonly ngControl;
+    aclValueTrackSkipFirst: boolean;
+    aclValueTrack: (value?: unknown) => void;
+    aclValueTrack$: Observable<(value?: unknown) => void>;
+    destroy$$: Subject<void>;
+    ngOnDestroy(): void;
+    ngOnInit(): void;
+    constructor(ngControl: NgControl);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ControlValueTraceDirective, [{ host: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ControlValueTraceDirective, "[aclValueTrack]", never, { "aclValueTrackSkipFirst": { "alias": "aclValueTrackSkipFirst"; "required": false; }; "aclValueTrack": { "alias": "aclValueTrack"; "required": false; }; }, {}, never, never, true, never>;
+}

package/esm2022/alauda-fe-dynamic-plugin-shared.mjs

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

package/esm2022/array-form-table/base-string-map-form.component.mjs

@@ -0,0 +1,92 @@
+import { Directive, inject } from '@angular/core';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import { ValidateRowDuplicateService } from '../services/form-row-duplicate/form-row-duplicate.service';
+import * as i0 from "@angular/core";
+const missingKeyValidator = control => {
+    const [key, value] = control.value;
+    return value && !key ? { keyIsMissing: true } : null;
+};
+// 用以Form级别的键值映射对象的修改.
+// 这个表单有些特别. 内部实现是以FormArray实现, 但对外暴露的是一个key->value对象.
+export class BaseStringMapFormComponent extends BaseResourceFormComponent {
+    constructor() {
+        super(...arguments);
+        this.rowDupService = inject(ValidateRowDuplicateService);
+    }
+    createForm() {
+        return this.fb.array([]);
+    }
+    getDefaultFormModel() {
+        return [];
+    }
+    adaptResourceModel(resource) {
+        let newFormModel = Object.entries(resource || {});
+        if (newFormModel.length === 0) {
+            newFormModel = this.getDefaultFormModel();
+        }
+        return newFormModel;
+    }
+    adaptFormModel(formModel) {
+        return formModel
+            .filter(row => !!row[0])
+            .reduce((obj, [k, v]) => ({ ...obj, [k]: v }), {});
+    }
+    getOnFormArrayResizeFn() {
+        return () => this.createNewControl();
+    }
+    add(index = this.form.length) {
+        this.form.insert(index, this.getOnFormArrayResizeFn()());
+        this.cdr.markForCheck();
+    }
+    remove(index) {
+        this.form.removeAt(index);
+        this.cdr.markForCheck();
+        this.form.controls.forEach(c => c.updateValueAndValidity());
+    }
+    getPreviousKeys(index) {
+        return this.formModel
+            .slice(0, index)
+            .map(([key]) => key)
+            .filter(key => !!key);
+    }
+    getKeyValidators() {
+        return [];
+    }
+    getValueValidators() {
+        return [];
+    }
+    createNewControl() {
+        return this.fb.array([
+            ['', this.getKeyValidators()],
+            ['', this.getValueValidators()],
+        ], [
+            missingKeyValidator,
+            (control) => {
+                if (control.controls[0].errors) {
+                    return {
+                        key: control.controls[0].errors,
+                    };
+                }
+                if (control.controls[1].errors) {
+                    return {
+                        value: control.controls[1].errors,
+                    };
+                }
+                return null;
+            },
+            this.rowDupService.createFormArrayValidator({
+                rowKeys: [{ key: ['0'] }],
+                formArray: this.form,
+            }),
+        ]);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseStringMapFormComponent, deps: null, target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: BaseStringMapFormComponent, isStandalone: true, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: BaseStringMapFormComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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