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

package/esm2022/components/text-tooltip/directive.mjs

@@ -0,0 +1,71 @@
+import { TooltipDirective } from '@alauda/ui';
+import { Directive, HostListener, Input, inject } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+const CLONE_ELEMENT_BASE_STYLES = {
+    position: 'absolute',
+    visibility: 'hidden',
+    zIndex: -999,
+};
+/**
+ * 使用场景：
+ * 文案需要单行显示，过长时截取的情况。
+ * 效果：
+ * 发生截取的文案会显示完整内容的 tooltip。未发生截取的文案不显示 tooltip。
+ * @example:
+ * <span class="tw-text-overflow" aclTextTooltip>TEXT...</span>
+ *
+ * tooltip 的一些设置（位置、类型）可以使用 aui 相同设置。未传 tooltip content 则取元素 text content
+ */
+export class TextTooltipDirective {
+    constructor() {
+        this.tooltipDirective = inject(TooltipDirective);
+    }
+    onMouseEnter(e) {
+        const el = e.target;
+        const displayWidth = el.offsetWidth;
+        const fullWidth = this.calcFullTextWidth(el);
+        this.tooltipDirective.content = this.content || el.textContent;
+        this.tooltipDirective.disabled = fullWidth <= displayWidth;
+    }
+    calcFullTextWidth(el) {
+        const computedStyle = window.getComputedStyle(el);
+        const contentContainer = document.createElement('div');
+        contentContainer.textContent = this.content || el.textContent;
+        Object.assign(contentContainer.style, {
+            ...CLONE_ELEMENT_BASE_STYLES,
+            fontSize: computedStyle.fontSize,
+            fontWeight: computedStyle.fontWeight,
+        });
+        document.body.append(contentContainer);
+        const width = contentContainer.offsetWidth;
+        contentContainer.remove();
+        return width;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextTooltipDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: TextTooltipDirective, isStandalone: true, selector: "[aclTextTooltip]", inputs: { content: ["aclTextTooltip", "content"] }, host: { listeners: { "mouseenter": "onMouseEnter($event)" } }, hostDirectives: [{ directive: i1.TooltipDirective, inputs: ["auiTooltip", "aclTextTooltip", "auiTooltipPosition", "auiTooltipPosition", "auiTooltipType", "auiTooltipType"] }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextTooltipDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aclTextTooltip]',
+                    hostDirectives: [
+                        {
+                            directive: TooltipDirective,
+                            inputs: [
+                                'auiTooltip:aclTextTooltip',
+                                'auiTooltipPosition',
+                                'auiTooltipType',
+                            ],
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { content: [{
+                type: Input,
+                args: ['aclTextTooltip']
+            }], onMouseEnter: [{
+                type: HostListener,
+                args: ['mouseenter', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2NvbXBvbmVudHMvdGV4dC10b29sdGlwL2RpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxZQUFZLENBQUM7QUFDOUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQzs7O0FBRXZFLE1BQU0seUJBQXlCLEdBQUc7SUFDaEMsUUFBUSxFQUFFLFVBQVU7SUFDcEIsVUFBVSxFQUFFLFFBQVE7SUFDcEIsTUFBTSxFQUFFLENBQUMsR0FBRztDQUNiLENBQUM7QUFFRjs7Ozs7Ozs7O0dBU0c7QUFlSCxNQUFNLE9BQU8sb0JBQW9CO0lBZGpDO1FBMkJFLHFCQUFnQixHQUFHLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0tBZ0I3QztJQXhCQyxZQUFZLENBQUMsQ0FBYTtRQUN4QixNQUFNLEVBQUUsR0FBRyxDQUFDLENBQUMsTUFBcUIsQ0FBQztRQUNuQyxNQUFNLFlBQVksR0FBRyxFQUFFLENBQUMsV0FBVyxDQUFDO1FBQ3BDLE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxFQUFFLENBQUMsQ0FBQztRQUM3QyxJQUFJLENBQUMsZ0JBQWdCLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDLFdBQVcsQ0FBQztRQUMvRCxJQUFJLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxHQUFHLFNBQVMsSUFBSSxZQUFZLENBQUM7SUFDN0QsQ0FBQztJQUlPLGlCQUFpQixDQUFDLEVBQWU7UUFDdkMsTUFBTSxhQUFhLEdBQUcsTUFBTSxDQUFDLGdCQUFnQixDQUFDLEVBQUUsQ0FBQyxDQUFDO1FBQ2xELE1BQU0sZ0JBQWdCLEdBQUcsUUFBUSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUN2RCxnQkFBZ0IsQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLE9BQU8sSUFBSSxFQUFFLENBQUMsV0FBVyxDQUFDO1FBQzlELE1BQU0sQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsS0FBSyxFQUFFO1lBQ3BDLEdBQUcseUJBQXlCO1lBQzVCLFFBQVEsRUFBRSxhQUFhLENBQUMsUUFBUTtZQUNoQyxVQUFVLEVBQUUsYUFBYSxDQUFDLFVBQVU7U0FDckMsQ0FBQyxDQUFDO1FBQ0gsUUFBUSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztRQUN2QyxNQUFNLEtBQUssR0FBRyxnQkFBZ0IsQ0FBQyxXQUFXLENBQUM7UUFDM0MsZ0JBQWdCLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDMUIsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDOzhHQTVCVSxvQkFBb0I7a0dBQXBCLG9CQUFvQjs7MkZBQXBCLG9CQUFvQjtrQkFkaEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsa0JBQWtCO29CQUM1QixjQUFjLEVBQUU7d0JBQ2Q7NEJBQ0UsU0FBUyxFQUFFLGdCQUFnQjs0QkFDM0IsTUFBTSxFQUFFO2dDQUNOLDJCQUEyQjtnQ0FDM0Isb0JBQW9CO2dDQUNwQixnQkFBZ0I7NkJBQ2pCO3lCQUNGO3FCQUNGO29CQUNELFVBQVUsRUFBRSxJQUFJO2lCQUNqQjs4QkFHQyxPQUFPO3NCQUROLEtBQUs7dUJBQUMsZ0JBQWdCO2dCQUl2QixZQUFZO3NCQURYLFlBQVk7dUJBQUMsWUFBWSxFQUFFLENBQUMsUUFBUSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgVG9vbHRpcERpcmVjdGl2ZSB9IGZyb20gJ0BhbGF1ZGEvdWknO1xuaW1wb3J0IHsgRGlyZWN0aXZlLCBIb3N0TGlzdGVuZXIsIElucHV0LCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuY29uc3QgQ0xPTkVfRUxFTUVOVF9CQVNFX1NUWUxFUyA9IHtcbiAgcG9zaXRpb246ICdhYnNvbHV0ZScsXG4gIHZpc2liaWxpdHk6ICdoaWRkZW4nLFxuICB6SW5kZXg6IC05OTksXG59O1xuXG4vKipcbiAqIOS9v+eUqOWcuuaZr++8mlxuICog5paH5qGI6ZyA6KaB5Y2V6KGM5pi+56S677yM6L+H6ZW/5pe25oiq5Y+W55qE5oOF5Ya144CCXG4gKiDmlYjmnpzvvJpcbiAqIOWPkeeUn+aIquWPlueahOaWh+ahiOS8muaYvuekuuWujOaVtOWGheWuueeahCB0b29sdGlw44CC5pyq5Y+R55Sf5oiq5Y+W55qE5paH5qGI5LiN5pi+56S6IHRvb2x0aXDjgIJcbiAqIEBleGFtcGxlOlxuICogPHNwYW4gY2xhc3M9XCJ0dy10ZXh0LW92ZXJmbG93XCIgYWNsVGV4dFRvb2x0aXA+VEVYVC4uLjwvc3Bhbj5cbiAqXG4gKiB0b29sdGlwIOeahOS4gOS6m+iuvue9ru+8iOS9jee9ruOAgeexu+Wei++8ieWPr+S7peS9v+eUqCBhdWkg55u45ZCM6K6+572u44CC5pyq5LygIHRvb2x0aXAgY29udGVudCDliJnlj5blhYPntKAgdGV4dCBjb250ZW50XG4gKi9cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1thY2xUZXh0VG9vbHRpcF0nLFxuICBob3N0RGlyZWN0aXZlczogW1xuICAgIHtcbiAgICAgIGRpcmVjdGl2ZTogVG9vbHRpcERpcmVjdGl2ZSxcbiAgICAgIGlucHV0czogW1xuICAgICAgICAnYXVpVG9vbHRpcDphY2xUZXh0VG9vbHRpcCcsXG4gICAgICAgICdhdWlUb29sdGlwUG9zaXRpb24nLFxuICAgICAgICAnYXVpVG9vbHRpcFR5cGUnLFxuICAgICAgXSxcbiAgICB9LFxuICBdLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBUZXh0VG9vbHRpcERpcmVjdGl2ZSB7XG4gIEBJbnB1dCgnYWNsVGV4dFRvb2x0aXAnKVxuICBjb250ZW50OiBzdHJpbmc7XG5cbiAgQEhvc3RMaXN0ZW5lcignbW91c2VlbnRlcicsIFsnJGV2ZW50J10pXG4gIG9uTW91c2VFbnRlcihlOiBNb3VzZUV2ZW50KSB7XG4gICAgY29uc3QgZWwgPSBlLnRhcmdldCBhcyBIVE1MRWxlbWVudDtcbiAgICBjb25zdCBkaXNwbGF5V2lkdGggPSBlbC5vZmZzZXRXaWR0aDtcbiAgICBjb25zdCBmdWxsV2lkdGggPSB0aGlzLmNhbGNGdWxsVGV4dFdpZHRoKGVsKTtcbiAgICB0aGlzLnRvb2x0aXBEaXJlY3RpdmUuY29udGVudCA9IHRoaXMuY29udGVudCB8fCBlbC50ZXh0Q29udGVudDtcbiAgICB0aGlzLnRvb2x0aXBEaXJlY3RpdmUuZGlzYWJsZWQgPSBmdWxsV2lkdGggPD0gZGlzcGxheVdpZHRoO1xuICB9XG5cbiAgdG9vbHRpcERpcmVjdGl2ZSA9IGluamVjdChUb29sdGlwRGlyZWN0aXZlKTtcblxuICBwcml2YXRlIGNhbGNGdWxsVGV4dFdpZHRoKGVsOiBIVE1MRWxlbWVudCkge1xuICAgIGNvbnN0IGNvbXB1dGVkU3R5bGUgPSB3aW5kb3cuZ2V0Q29tcHV0ZWRTdHlsZShlbCk7XG4gICAgY29uc3QgY29udGVudENvbnRhaW5lciA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2RpdicpO1xuICAgIGNvbnRlbnRDb250YWluZXIudGV4dENvbnRlbnQgPSB0aGlzLmNvbnRlbnQgfHwgZWwudGV4dENvbnRlbnQ7XG4gICAgT2JqZWN0LmFzc2lnbihjb250ZW50Q29udGFpbmVyLnN0eWxlLCB7XG4gICAgICAuLi5DTE9ORV9FTEVNRU5UX0JBU0VfU1RZTEVTLFxuICAgICAgZm9udFNpemU6IGNvbXB1dGVkU3R5bGUuZm9udFNpemUsXG4gICAgICBmb250V2VpZ2h0OiBjb21wdXRlZFN0eWxlLmZvbnRXZWlnaHQsXG4gICAgfSk7XG4gICAgZG9jdW1lbnQuYm9keS5hcHBlbmQoY29udGVudENvbnRhaW5lcik7XG4gICAgY29uc3Qgd2lkdGggPSBjb250ZW50Q29udGFpbmVyLm9mZnNldFdpZHRoO1xuICAgIGNvbnRlbnRDb250YWluZXIucmVtb3ZlKCk7XG4gICAgcmV0dXJuIHdpZHRoO1xuICB9XG59XG4iXX0=

package/esm2022/components/text-with-url/component.mjs

@@ -0,0 +1,40 @@
+import { NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { PurePipe } from '../../pipes';
+import * as i0 from "@angular/core";
+export class TextWithUrlComponent {
+    constructor() {
+        this.parseUrlInText = parseUrlInText;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextWithUrlComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: TextWithUrlComponent, isStandalone: true, selector: "acl-text-with-url", inputs: { text: "text" }, ngImport: i0, template: "<ng-container *ngFor=\"let item of text | pure: parseUrlInText\">\n  <span *ngIf=\"item.type === 'plain'\">{{ item.value }}</span>\n  <a\n    *ngIf=\"item.type === 'url'\"\n    [href]=\"item.value\"\n    target=\"_blank\"\n    >{{ item.value }}</a\n  >\n</ng-container>\n", dependencies: [{ kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "pipe", type: PurePipe, name: "pure" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: TextWithUrlComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-text-with-url', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, imports: [NgFor, NgIf, PurePipe], template: "<ng-container *ngFor=\"let item of text | pure: parseUrlInText\">\n  <span *ngIf=\"item.type === 'plain'\">{{ item.value }}</span>\n  <a\n    *ngIf=\"item.type === 'url'\"\n    [href]=\"item.value\"\n    target=\"_blank\"\n    >{{ item.value }}</a\n  >\n</ng-container>\n" }]
+        }], propDecorators: { text: [{
+                type: Input
+            }] } });
+export function parseUrlInText(text) {
+    const urlRegex = /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\w$&+,:;=-]+@)?[\d.A-Za-z-]+|(?:www.|[\w$&+,:;=-]+@)[\d.A-Za-z-]+)((?:\/[\w%+./~-]*)?\??[\w%&+.;=@-]*#?\w*)?)/g;
+    const urlMatches = text.match(urlRegex);
+    if (!urlMatches) {
+        return [{ value: text, type: 'plain' }];
+    }
+    const result = [];
+    let i = 0;
+    while (text?.length) {
+        const url = urlMatches[i++];
+        if (url) {
+            const index = text.indexOf(url);
+            result.push({ value: text.slice(0, Math.max(0, index)), type: 'plain' }, { value: url, type: 'url' });
+            text = text.slice(Math.max(0, index + url.length));
+        }
+        else {
+            result.push({ value: text, type: 'plain' });
+            break;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/upload-file/component.mjs

@@ -0,0 +1,95 @@
+import { NotificationService, coerceAttrBoolean } from '@alauda/ui';
+import { TranslateService } from '@alauda-fe/dynamic-plugin-sdk';
+import { ChangeDetectionStrategy, Component, Input, forwardRef, HostListener, ViewChild, ElementRef, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { EFFECT_DIRECTIVE_MODULE } from '../../directives';
+import { isErrorMessage } from '../../types';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "@alauda-fe/dynamic-plugin-sdk";
+export const FileResultType = {
+    ARRAY_BUFFER: 'ArrayBuffer',
+    BINARY_STRING: 'BinaryString',
+    DATA_URL: 'DataURL',
+    TEXT: 'Text',
+};
+export class UploadFileComponent {
+    constructor(notification, translate) {
+        this.notification = notification;
+        this.translate = translate;
+        this.resultType = FileResultType.TEXT;
+    }
+    onClick() {
+        if (coerceAttrBoolean(this.disabled)) {
+            return;
+        }
+        this.fileInput.nativeElement.click();
+    }
+    async onChange(e) {
+        const el = e.target;
+        try {
+            const results = await Promise.all(Array.from(el.files).map(file => new Promise((resolve, reject) => {
+                const fileReader = new FileReader();
+                fileReader.addEventListener('load', () => {
+                    const { result } = fileReader;
+                    if (this.resultType === FileResultType.TEXT &&
+                        result.includes('\uFFFD')) {
+                        reject(new Error(this.translate.get('text_file_type_error')));
+                        return;
+                    }
+                    resolve(result);
+                });
+                fileReader[`readAs${this.resultType}`](file);
+            })));
+            this.valueChange(this.multiple ? results : results[0]);
+        }
+        catch (e) {
+            if (isErrorMessage(e)) {
+                this.notification.error(e.message);
+            }
+        }
+        el.value = null;
+    }
+    writeValue() {
+        //
+    }
+    registerOnChange(fn) {
+        this.valueChange = fn;
+    }
+    registerOnTouched() {
+        //
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: UploadFileComponent, deps: [{ token: i1.NotificationService }, { token: i2.TranslateService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.1.1", type: UploadFileComponent, isStandalone: true, selector: "acl-upload-file", inputs: { disabled: "disabled", accept: "accept", multiple: "multiple", resultType: "resultType" }, host: { listeners: { "click": "onClick()" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => UploadFileComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "fileInput", first: true, predicate: ["fileInput"], descendants: true }], ngImport: i0, template: "<ng-content></ng-content>\n<input\n  #fileInput\n  class=\"file-input\"\n  type=\"file\"\n  [attr.accept]=\"accept\"\n  [multiple]=\"multiple\"\n  (change)=\"onChange($event)\"\n/>\n", styles: [":host{position:relative;display:inline-flex;overflow:hidden}.file-input{position:absolute;top:0;right:0;bottom:0;left:0;opacity:0;z-index:-1}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: UploadFileComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-upload-file', preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => UploadFileComponent),
+                            multi: true,
+                        },
+                    ], standalone: true, imports: [EFFECT_DIRECTIVE_MODULE], template: "<ng-content></ng-content>\n<input\n  #fileInput\n  class=\"file-input\"\n  type=\"file\"\n  [attr.accept]=\"accept\"\n  [multiple]=\"multiple\"\n  (change)=\"onChange($event)\"\n/>\n", styles: [":host{position:relative;display:inline-flex;overflow:hidden}.file-input{position:absolute;top:0;right:0;bottom:0;left:0;opacity:0;z-index:-1}\n"] }]
+        }], ctorParameters: () => [{ type: i1.NotificationService }, { type: i2.TranslateService }], propDecorators: { disabled: [{
+                type: Input
+            }], accept: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], resultType: [{
+                type: Input
+            }], fileInput: [{
+                type: ViewChild,
+                args: ['fileInput']
+            }], onClick: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/components/zero-state/zero-state.component.mjs

@@ -0,0 +1,51 @@
+import { handlePixel, isTemplateRef } from '@alauda/ui';
+import { TranslatePipe } from '@alauda-fe/dynamic-plugin-sdk';
+import { NgClass, NgIf, NgStyle, NgTemplateOutlet } from '@angular/common';
+import { ChangeDetectionStrategy, Component, HostBinding, Input, } from '@angular/core';
+import { PurePipe } from '../../pipes';
+import { LoadingMaskComponent } from '../loading-mask/loading-mask.component';
+import * as i0 from "@angular/core";
+export class ZeroStateComponent {
+    constructor() {
+        this.zeroState = true;
+        this.fetching = false;
+        this.context = 'form';
+        this.handlePixel = handlePixel;
+        this.isTemplateRef = isTemplateRef;
+    }
+    get hiddenState() {
+        return !this.zeroState && !this.fetching;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ZeroStateComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.1.1", type: ZeroStateComponent, isStandalone: true, selector: "acl-zero-state", inputs: { resourceName: "resourceName", resourceNameTranslated: "resourceNameTranslated", customPlaceholder: "customPlaceholder", zeroState: "zeroState", fetching: "fetching", context: "context", minHeight: "minHeight" }, host: { properties: { "hidden": "this.hiddenState" } }, ngImport: i0, template: "<div\n  *ngIf=\"zeroState && !fetching\"\n  class=\"zero-placeholder\"\n  [ngClass]=\"context\"\n  [ngStyle]=\"{\n    minHeight: (minHeight | pure: handlePixel),\n  }\"\n>\n  @if (customPlaceholder) {\n    <ng-container\n      [ngTemplateOutlet]=\"\n        isTemplateRef(customPlaceholder) ? customPlaceholder : literal\n      \"\n    ></ng-container>\n    <ng-template #literal>{{ customPlaceholder }}</ng-template>\n  } @else if (!(resourceName || resourceNameTranslated)) {\n    {{ 'no_data' | translate }}\n  } @else {\n    {{\n      'no_named_data_hint'\n        | translate\n          : {\n              name: resourceNameTranslated || (resourceName | translate),\n            }\n    }}\n  }\n</div>\n<acl-loading-mask\n  class=\"zero-placeholder\"\n  [loading]=\"fetching\"\n></acl-loading-mask>\n", styles: [":host::ng-deep .zero-placeholder{box-sizing:border-box;display:flex;justify-content:center;align-items:center;padding:15px 10px;min-height:60px;font-size:var(--aui-font-size-m);line-height:var(--aui-line-height-m);font-weight:var(--aui-font-weight-normal);color:rgb(var(--aui-color-placeholder-text));background-color:rgb(var(--aui-color-n-10));border:solid 1px rgb(var(--aui-color-n-8));border-radius:var(--aui-border-radius-l);position:sticky;left:0}:host::ng-deep .zero-placeholder>aui-icon:first-child{margin-right:var(--aui-spacing-m)}:host::ng-deep .aui-table .aui-table__row+.zero-placeholder{border-top-left-radius:0;border-top-right-radius:0}.zero-placeholder.form{border:none;padding:14px 0}\n"], dependencies: [{ kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { kind: "pipe", type: PurePipe, name: "pure" }, { kind: "pipe", type: TranslatePipe, name: "translate" }, { kind: "component", type: LoadingMaskComponent, selector: "acl-loading-mask", inputs: ["loading", "type", "text"] }, { kind: "directive", type: NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: ZeroStateComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'acl-zero-state', changeDetection: ChangeDetectionStrategy.OnPush, imports: [
+                        NgClass,
+                        NgStyle,
+                        PurePipe,
+                        TranslatePipe,
+                        LoadingMaskComponent,
+                        NgTemplateOutlet,
+                        NgIf,
+                    ], standalone: true, template: "<div\n  *ngIf=\"zeroState && !fetching\"\n  class=\"zero-placeholder\"\n  [ngClass]=\"context\"\n  [ngStyle]=\"{\n    minHeight: (minHeight | pure: handlePixel),\n  }\"\n>\n  @if (customPlaceholder) {\n    <ng-container\n      [ngTemplateOutlet]=\"\n        isTemplateRef(customPlaceholder) ? customPlaceholder : literal\n      \"\n    ></ng-container>\n    <ng-template #literal>{{ customPlaceholder }}</ng-template>\n  } @else if (!(resourceName || resourceNameTranslated)) {\n    {{ 'no_data' | translate }}\n  } @else {\n    {{\n      'no_named_data_hint'\n        | translate\n          : {\n              name: resourceNameTranslated || (resourceName | translate),\n            }\n    }}\n  }\n</div>\n<acl-loading-mask\n  class=\"zero-placeholder\"\n  [loading]=\"fetching\"\n></acl-loading-mask>\n", styles: [":host::ng-deep .zero-placeholder{box-sizing:border-box;display:flex;justify-content:center;align-items:center;padding:15px 10px;min-height:60px;font-size:var(--aui-font-size-m);line-height:var(--aui-line-height-m);font-weight:var(--aui-font-weight-normal);color:rgb(var(--aui-color-placeholder-text));background-color:rgb(var(--aui-color-n-10));border:solid 1px rgb(var(--aui-color-n-8));border-radius:var(--aui-border-radius-l);position:sticky;left:0}:host::ng-deep .zero-placeholder>aui-icon:first-child{margin-right:var(--aui-spacing-m)}:host::ng-deep .aui-table .aui-table__row+.zero-placeholder{border-top-left-radius:0;border-top-right-radius:0}.zero-placeholder.form{border:none;padding:14px 0}\n"] }]
+        }], propDecorators: { resourceName: [{
+                type: Input
+            }], resourceNameTranslated: [{
+                type: Input
+            }], customPlaceholder: [{
+                type: Input
+            }], zeroState: [{
+                type: Input
+            }], fetching: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], hiddenState: [{
+                type: HostBinding,
+                args: ['hidden']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemVyby1zdGF0ZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvY29tcG9uZW50cy96ZXJvLXN0YXRlL3plcm8tc3RhdGUuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2NvbXBvbmVudHMvemVyby1zdGF0ZS96ZXJvLXN0YXRlLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxXQUFXLEVBQUUsYUFBYSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQ3hELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUM5RCxPQUFPLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMzRSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLFNBQVMsRUFDVCxXQUFXLEVBQ1gsS0FBSyxHQUVOLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDdkMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sd0NBQXdDLENBQUM7O0FBa0I5RSxNQUFNLE9BQU8sa0JBQWtCO0lBaEIvQjtRQTBCRSxjQUFTLEdBQUcsSUFBSSxDQUFDO1FBR2pCLGFBQVEsR0FBRyxLQUFLLENBQUM7UUFHakIsWUFBTyxHQUFxQixNQUFNLENBQUM7UUFVbkMsZ0JBQVcsR0FBRyxXQUFXLENBQUM7UUFFMUIsa0JBQWEsR0FBRyxhQUFhLENBQUM7S0FDL0I7SUFSQyxJQUNJLFdBQVc7UUFDYixPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsSUFBSSxDQUFDLElBQUksQ0FBQyxRQUFRLENBQUM7SUFDM0MsQ0FBQzs4R0F4QlUsa0JBQWtCO2tHQUFsQixrQkFBa0IsZ1dDOUIvQix1eUJBK0JBLHl2QkRYSSxPQUFPLG9GQUNQLE9BQU8sc0VBQ1AsUUFBUSx3Q0FDUixhQUFhLGtEQUNiLG9CQUFvQixrR0FDcEIsZ0JBQWdCLG9KQUNoQixJQUFJOzsyRkFJSyxrQkFBa0I7a0JBaEI5QixTQUFTOytCQUNFLGdCQUFnQixtQkFHVCx1QkFBdUIsQ0FBQyxNQUFNLFdBQ3RDO3dCQUNQLE9BQU87d0JBQ1AsT0FBTzt3QkFDUCxRQUFRO3dCQUNSLGFBQWE7d0JBQ2Isb0JBQW9CO3dCQUNwQixnQkFBZ0I7d0JBQ2hCLElBQUk7cUJBQ0wsY0FDVyxJQUFJOzhCQUloQixZQUFZO3NCQURYLEtBQUs7Z0JBSU4sc0JBQXNCO3NCQURyQixLQUFLO2dCQUdHLGlCQUFpQjtzQkFBekIsS0FBSztnQkFHTixTQUFTO3NCQURSLEtBQUs7Z0JBSU4sUUFBUTtzQkFEUCxLQUFLO2dCQUlOLE9BQU87c0JBRE4sS0FBSztnQkFJTixTQUFTO3NCQURSLEtBQUs7Z0JBSUYsV0FBVztzQkFEZCxXQUFXO3VCQUFDLFFBQVEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBoYW5kbGVQaXhlbCwgaXNUZW1wbGF0ZVJlZiB9IGZyb20gJ0BhbGF1ZGEvdWknO1xuaW1wb3J0IHsgVHJhbnNsYXRlUGlwZSB9IGZyb20gJ0BhbGF1ZGEtZmUvZHluYW1pYy1wbHVnaW4tc2RrJztcbmltcG9ydCB7IE5nQ2xhc3MsIE5nSWYsIE5nU3R5bGUsIE5nVGVtcGxhdGVPdXRsZXQgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbiAgSG9zdEJpbmRpbmcsXG4gIElucHV0LFxuICBUZW1wbGF0ZVJlZixcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IFB1cmVQaXBlIH0gZnJvbSAnLi4vLi4vcGlwZXMnO1xuaW1wb3J0IHsgTG9hZGluZ01hc2tDb21wb25lbnQgfSBmcm9tICcuLi9sb2FkaW5nLW1hc2svbG9hZGluZy1tYXNrLmNvbXBvbmVudCc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2FjbC16ZXJvLXN0YXRlJyxcbiAgdGVtcGxhdGVVcmw6ICcuL3plcm8tc3RhdGUuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsnLi96ZXJvLXN0YXRlLmNvbXBvbmVudC5zY3NzJ10sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBpbXBvcnRzOiBbXG4gICAgTmdDbGFzcyxcbiAgICBOZ1N0eWxlLFxuICAgIFB1cmVQaXBlLFxuICAgIFRyYW5zbGF0ZVBpcGUsXG4gICAgTG9hZGluZ01hc2tDb21wb25lbnQsXG4gICAgTmdUZW1wbGF0ZU91dGxldCxcbiAgICBOZ0lmLFxuICBdLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBaZXJvU3RhdGVDb21wb25lbnQge1xuICBASW5wdXQoKVxuICByZXNvdXJjZU5hbWU6IHN0cmluZztcblxuICBASW5wdXQoKVxuICByZXNvdXJjZU5hbWVUcmFuc2xhdGVkOiBzdHJpbmc7XG5cbiAgQElucHV0KCkgY3VzdG9tUGxhY2Vob2xkZXI6IFRlbXBsYXRlUmVmPHVua25vd24+IHwgc3RyaW5nO1xuXG4gIEBJbnB1dCgpXG4gIHplcm9TdGF0ZSA9IHRydWU7XG5cbiAgQElucHV0KClcbiAgZmV0Y2hpbmcgPSBmYWxzZTtcblxuICBASW5wdXQoKVxuICBjb250ZXh0OiAnZm9ybScgfCAndGFibGUnID0gJ2Zvcm0nO1xuXG4gIEBJbnB1dCgpXG4gIG1pbkhlaWdodDogc3RyaW5nIHwgbnVtYmVyO1xuXG4gIEBIb3N0QmluZGluZygnaGlkZGVuJylcbiAgZ2V0IGhpZGRlblN0YXRlKCkge1xuICAgIHJldHVybiAhdGhpcy56ZXJvU3RhdGUgJiYgIXRoaXMuZmV0Y2hpbmc7XG4gIH1cblxuICBoYW5kbGVQaXhlbCA9IGhhbmRsZVBpeGVsO1xuXG4gIGlzVGVtcGxhdGVSZWYgPSBpc1RlbXBsYXRlUmVmO1xufVxuIiwiPGRpdlxuICAqbmdJZj1cInplcm9TdGF0ZSAmJiAhZmV0Y2hpbmdcIlxuICBjbGFzcz1cInplcm8tcGxhY2Vob2xkZXJcIlxuICBbbmdDbGFzc109XCJjb250ZXh0XCJcbiAgW25nU3R5bGVdPVwie1xuICAgIG1pbkhlaWdodDogKG1pbkhlaWdodCB8IHB1cmU6IGhhbmRsZVBpeGVsKSxcbiAgfVwiXG4+XG4gIEBpZiAoY3VzdG9tUGxhY2Vob2xkZXIpIHtcbiAgICA8bmctY29udGFpbmVyXG4gICAgICBbbmdUZW1wbGF0ZU91dGxldF09XCJcbiAgICAgICAgaXNUZW1wbGF0ZVJlZihjdXN0b21QbGFjZWhvbGRlcikgPyBjdXN0b21QbGFjZWhvbGRlciA6IGxpdGVyYWxcbiAgICAgIFwiXG4gICAgPjwvbmctY29udGFpbmVyPlxuICAgIDxuZy10ZW1wbGF0ZSAjbGl0ZXJhbD57eyBjdXN0b21QbGFjZWhvbGRlciB9fTwvbmctdGVtcGxhdGU+XG4gIH0gQGVsc2UgaWYgKCEocmVzb3VyY2VOYW1lIHx8IHJlc291cmNlTmFtZVRyYW5zbGF0ZWQpKSB7XG4gICAge3sgJ25vX2RhdGEnIHwgdHJhbnNsYXRlIH19XG4gIH0gQGVsc2Uge1xuICAgIHt7XG4gICAgICAnbm9fbmFtZWRfZGF0YV9oaW50J1xuICAgICAgICB8IHRyYW5zbGF0ZVxuICAgICAgICAgIDoge1xuICAgICAgICAgICAgICBuYW1lOiByZXNvdXJjZU5hbWVUcmFuc2xhdGVkIHx8IChyZXNvdXJjZU5hbWUgfCB0cmFuc2xhdGUpLFxuICAgICAgICAgICAgfVxuICAgIH19XG4gIH1cbjwvZGl2PlxuPGFjbC1sb2FkaW5nLW1hc2tcbiAgY2xhc3M9XCJ6ZXJvLXBsYWNlaG9sZGVyXCJcbiAgW2xvYWRpbmddPVwiZmV0Y2hpbmdcIlxuPjwvYWNsLWxvYWRpbmctbWFzaz5cbiJdfQ==

package/esm2022/constants/common.mjs

@@ -0,0 +1,86 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+export const API_GATEWAY = '{{API_GATEWAY}}';
+export const TRUE = 'true';
+export const FALSE = 'false';
+export const EMPTY = '';
+export const SPACE = ' ';
+export const DOT = '.';
+export const SLASH = '/';
+export const HYPHEN = '-';
+export const UNDERSCORE = '_';
+export const DELIMITER = ':';
+export const WILDCARD = '.*';
+export const DATE_FORMAT = 'YYYY-MM-DD';
+export const TIME_FORMAT = 'HH:mm:ss';
+export const DATE_TIME_FORMAT = `${DATE_FORMAT} ${TIME_FORMAT}`;
+export const WORKSPACE_PARAMS = 'workspace_params_v1';
+export const PUBLIC_NAMESPACE = 'kube-public';
+export const ASSIGN_ALL = 'ALL_ALL';
+export const ALL = 'ALL';
+export const Bracket = {
+    PARENTHESES: ['(', ')'],
+    BRACES: ['{', '}'],
+    SQUARE_BRACKETS: ['[', ']'],
+    POINTY_BRACKETS: ['<', '>'],
+};
+export const TEMPLATE_OPTIONS = Object.freeze({
+    interpolate: /{{([\S\s]+?)}}/g,
+});
+export const DEFAULT_CODE_EDITOR_OPTIONS = {
+    fontSize: 12,
+    folding: true,
+    scrollBeyondLastLine: false,
+    minimap: { enabled: false },
+    find: {
+        seedSearchStringFromSelection: 'never',
+        autoFindInSelection: 'never',
+    },
+    mouseWheelZoom: true,
+    scrollbar: {
+        vertical: 'visible',
+        horizontal: 'visible',
+    },
+    fixedOverflowWidgets: true,
+};
+export const NOTIFY_ON_ERROR_HEADER = '__NOTIFICATION_ON_ERROR__';
+export const NOTIFY_DURATION_HEADER = '__NOTIFICATION_DURATION__';
+export const NOTIFY_ON_ERROR_HEADERS = {
+    [NOTIFY_ON_ERROR_HEADER]: TRUE,
+};
+export const NOT_NOTIFY_ON_ERROR_HEADERS = {
+    [NOTIFY_ON_ERROR_HEADER]: FALSE,
+};
+// 当前环境是否允许降级
+// 'enabled_downgrade_watch' 主要提供本地开发强制打开需要
+export const DOWNGRADE_WATCH_ENABLED = localStorage.getItem('enabled_downgrade_watch') === TRUE ||
+    (document.location.protocol !== 'https:' &&
+        document.location.hostname !== 'localhost');
+export const DOWNGRADE_WATCH_POLLING = 5000;
+export const CREATED_AT = 'created_at';
+export const UPDATED_AT = 'updated_at';
+export const ACTION = 'action';
+export const SPEC = 'spec';
+export const CREATE = 'create';
+export const UPDATE = 'update';
+export const LINK = 'link';
+export const ESCAPE_DEACTIVATE_CHECK = 'escape';
+export const CUSTOMIZED = 'customized';
+export const GLOBAL_CLUSTER = 'global';
+export const PACKAGE_RUNTIME_VALUE = 'Runtime';
+export const CRYPTO_HEADER_KEY = 'X-Param-Response';
+export var CRYPTO_TYPE;
+(function (CRYPTO_TYPE) {
+    CRYPTO_TYPE["Enable"] = "Force";
+    CRYPTO_TYPE["Drop"] = "Drop";
+    CRYPTO_TYPE["Disable"] = "None";
+})(CRYPTO_TYPE || (CRYPTO_TYPE = {}));
+export const CRYPTO_RANDOM_HEADER_KEY = 'X-Param-Init';
+export const CRYPTO_KEY = 'alauda';
+export const PLATFORM_OPS_MODE = 'platform-ops-mode';
+// https://kubernetes.io/docs/reference/labels-annotations-taints/#kubectl-kubernetes-io-default-container
+export const DEFAULT_CONTAINER_ANNOTATION = 'kubectl.kubernetes.io/default-container';
+export const NOTIFICATION_SERVER_NAME = 'platform-email-server';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/constants/common.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nexport const API_GATEWAY = '{{API_GATEWAY}}';\n\nexport const TRUE = 'true';\nexport const FALSE = 'false';\n\nexport const EMPTY = '';\nexport const SPACE = ' ';\nexport const DOT = '.';\nexport const SLASH = '/';\nexport const HYPHEN = '-';\nexport const UNDERSCORE = '_';\nexport const DELIMITER = ':';\n\nexport const WILDCARD = '.*';\n\nexport const DATE_FORMAT = 'YYYY-MM-DD';\nexport const TIME_FORMAT = 'HH:mm:ss';\nexport const DATE_TIME_FORMAT = `${DATE_FORMAT} ${TIME_FORMAT}`;\n\nexport const WORKSPACE_PARAMS = 'workspace_params_v1';\n\nexport const PUBLIC_NAMESPACE = 'kube-public';\n\nexport const ASSIGN_ALL = 'ALL_ALL';\nexport const ALL = 'ALL';\n\nexport const Bracket = {\n  PARENTHESES: ['(', ')'],\n  BRACES: ['{', '}'],\n  SQUARE_BRACKETS: ['[', ']'],\n  POINTY_BRACKETS: ['<', '>'],\n} as const;\n\nexport const TEMPLATE_OPTIONS = Object.freeze({\n  interpolate: /{{([\\S\\s]+?)}}/g,\n});\n\nexport const DEFAULT_CODE_EDITOR_OPTIONS: import('@alauda/code-editor').MonacoEditorOptions =\n  {\n    fontSize: 12,\n    folding: true,\n    scrollBeyondLastLine: false,\n    minimap: { enabled: false },\n    find: {\n      seedSearchStringFromSelection: 'never',\n      autoFindInSelection: 'never',\n    },\n    mouseWheelZoom: true,\n    scrollbar: {\n      vertical: 'visible',\n      horizontal: 'visible',\n    },\n    fixedOverflowWidgets: true,\n  };\n\nexport const NOTIFY_ON_ERROR_HEADER = '__NOTIFICATION_ON_ERROR__';\n\nexport const NOTIFY_DURATION_HEADER = '__NOTIFICATION_DURATION__';\n\nexport const NOTIFY_ON_ERROR_HEADERS = {\n  [NOTIFY_ON_ERROR_HEADER]: TRUE,\n} as const;\n\nexport const NOT_NOTIFY_ON_ERROR_HEADERS = {\n  [NOTIFY_ON_ERROR_HEADER]: FALSE,\n} as const;\n\n// 当前环境是否允许降级\n// 'enabled_downgrade_watch' 主要提供本地开发强制打开需要\nexport const DOWNGRADE_WATCH_ENABLED =\n  localStorage.getItem('enabled_downgrade_watch') === TRUE ||\n  (document.location.protocol !== 'https:' &&\n    document.location.hostname !== 'localhost');\n\nexport const DOWNGRADE_WATCH_POLLING = 5000 as const;\n\nexport const CREATED_AT = 'created_at';\nexport const UPDATED_AT = 'updated_at';\nexport const ACTION = 'action';\nexport const SPEC = 'spec';\nexport const CREATE = 'create';\nexport const UPDATE = 'update';\nexport const LINK = 'link';\n\nexport const ESCAPE_DEACTIVATE_CHECK = 'escape';\n\nexport const CUSTOMIZED = 'customized';\n\nexport const GLOBAL_CLUSTER = 'global';\n\nexport const PACKAGE_RUNTIME_VALUE = 'Runtime';\n\nexport const CRYPTO_HEADER_KEY = 'X-Param-Response';\nexport enum CRYPTO_TYPE {\n  Enable = 'Force',\n  Drop = 'Drop',\n  Disable = 'None',\n}\nexport const CRYPTO_RANDOM_HEADER_KEY = 'X-Param-Init';\nexport const CRYPTO_KEY = 'alauda';\n\nexport const PLATFORM_OPS_MODE = 'platform-ops-mode';\n\n// https://kubernetes.io/docs/reference/labels-annotations-taints/#kubectl-kubernetes-io-default-container\nexport const DEFAULT_CONTAINER_ANNOTATION =\n  'kubectl.kubernetes.io/default-container';\n\nexport const NOTIFICATION_SERVER_NAME = 'platform-email-server';\n"]}

package/esm2022/constants/index.mjs

@@ -0,0 +1,7 @@
+export * from './common';
+export * from './k8s';
+export * from './patterns';
+export * from './status-icons';
+export * from './timezones';
+export * from './resource-definitions';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2R5bmFtaWMtcGx1Z2luLXNoYXJlZC9zcmMvY29uc3RhbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsT0FBTyxDQUFDO0FBQ3RCLGNBQWMsWUFBWSxDQUFDO0FBQzNCLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29tbW9uJztcbmV4cG9ydCAqIGZyb20gJy4vazhzJztcbmV4cG9ydCAqIGZyb20gJy4vcGF0dGVybnMnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGF0dXMtaWNvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90aW1lem9uZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXNvdXJjZS1kZWZpbml0aW9ucyc7XG4iXX0=

package/esm2022/constants/k8s.mjs

@@ -0,0 +1,13 @@
+export const METADATA = 'metadata';
+export const NAMESPACE = 'namespace';
+export const NAME = 'name';
+export const CREATION_TIMESTAMP = 'creationTimestamp';
+export const ANNOTATIONS = 'annotations';
+export const LABELS = 'labels';
+export const DISPLAY_NAME = 'display-name';
+export const DESCRIPTION = 'description';
+export const CREATOR = 'creator';
+export const UPDATED__AT = 'updated-at';
+export const PROJECT = 'project';
+export const CLUSTER = 'cluster';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiazhzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9keW5hbWljLXBsdWdpbi1zaGFyZWQvc3JjL2NvbnN0YW50cy9rOHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHLFVBQVUsQ0FBQztBQUNuQyxNQUFNLENBQUMsTUFBTSxTQUFTLEdBQUcsV0FBVyxDQUFDO0FBQ3JDLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxNQUFNLENBQUM7QUFDM0IsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsbUJBQW1CLENBQUM7QUFDdEQsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLGFBQWEsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsUUFBUSxDQUFDO0FBQy9CLE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBRyxjQUFjLENBQUM7QUFDM0MsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFHLGFBQWEsQ0FBQztBQUN6QyxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDO0FBQ2pDLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxZQUFZLENBQUM7QUFDeEMsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLFNBQVMsQ0FBQztBQUNqQyxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IE1FVEFEQVRBID0gJ21ldGFkYXRhJztcbmV4cG9ydCBjb25zdCBOQU1FU1BBQ0UgPSAnbmFtZXNwYWNlJztcbmV4cG9ydCBjb25zdCBOQU1FID0gJ25hbWUnO1xuZXhwb3J0IGNvbnN0IENSRUFUSU9OX1RJTUVTVEFNUCA9ICdjcmVhdGlvblRpbWVzdGFtcCc7XG5leHBvcnQgY29uc3QgQU5OT1RBVElPTlMgPSAnYW5ub3RhdGlvbnMnO1xuZXhwb3J0IGNvbnN0IExBQkVMUyA9ICdsYWJlbHMnO1xuZXhwb3J0IGNvbnN0IERJU1BMQVlfTkFNRSA9ICdkaXNwbGF5LW5hbWUnO1xuZXhwb3J0IGNvbnN0IERFU0NSSVBUSU9OID0gJ2Rlc2NyaXB0aW9uJztcbmV4cG9ydCBjb25zdCBDUkVBVE9SID0gJ2NyZWF0b3InO1xuZXhwb3J0IGNvbnN0IFVQREFURURfX0FUID0gJ3VwZGF0ZWQtYXQnO1xuZXhwb3J0IGNvbnN0IFBST0pFQ1QgPSAncHJvamVjdCc7XG5leHBvcnQgY29uc3QgQ0xVU1RFUiA9ICdjbHVzdGVyJztcbiJdfQ==

package/esm2022/constants/patterns.mjs

@@ -0,0 +1,142 @@
+export const DOMAIN_PATTERN_BASE = '^([\\da-z.-]+)\\.([a-z.]{2,6})$';
+export const IP_PATTERN_BASE = '^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})$';
+export const IPV6_PATTERN_BASE = '^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9]))$';
+const PROTOCOL_PATTERN_BASE = 'https?://';
+const PORT_PATTERN_BASE = '(:(6553[0-5]|655[0-2]\\d|65[0-4]\\d\\d|6[0-4]\\d\\d\\d|[1-5]\\d\\d\\d\\d|[1-9]\\d\\d\\d|[1-9]\\d\\d|[1-9]\\d|[1-9]))';
+const addPortAndProtocol = (patternStr) => {
+    const main = patternStr.replace(/(^\^)?/, '').replace(/(\$?)$/, '');
+    return `^(${PROTOCOL_PATTERN_BASE})?${main}(${PORT_PATTERN_BASE})?$`;
+};
+const addPortAndProtocolForIpv6 = (patternStr) => {
+    const main = patternStr.replace(/(^\^)?/, '').replace(/(\$?)$/, '');
+    return `(${patternStr})|(^(${PROTOCOL_PATTERN_BASE})\\[${main}\\]$)|(^(${PROTOCOL_PATTERN_BASE})?\\[${main}\\](${PORT_PATTERN_BASE})$)`;
+};
+export const PORT_PATTERN = {
+    pattern: /(^[1-9]\d{0,3}$)|(^[1-5]\d{4}$)|^(6[0-4]\d{3}$)|(^65[0-4]\d{2}$)|(^655[0-2]\d$)|(^6553[0-5]$)/,
+    tip: 'invalid_port',
+};
+// include ipv4, domain
+export const IP_ADDRESS_HOSTNAME_PATTERN = {
+    pattern: new RegExp(`(${IP_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})`),
+    tip: 'regexp_tip_ip_address_or_hostname',
+};
+// include ipv6, domain
+export const IPV6_ADDRESS_HOSTNAME_PATTERN = {
+    pattern: new RegExp(`(${IPV6_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})`),
+    tip: 'regexp_tip_ipv6_address_or_hostname',
+};
+// include ipv4, domain, and support port and protocol
+export const IP_ADDRESS_HOSTNAME_PORT_PATTERN = {
+    pattern: new RegExp(`(${addPortAndProtocol(IP_PATTERN_BASE)})|(${addPortAndProtocol(DOMAIN_PATTERN_BASE)})`),
+    tip: 'regexp_tip_ip_address_or_hostname',
+};
+// include ipv6, domain, and support port and protocol
+export const IPV6_ADDRESS_HOSTNAME_PORT_PATTERN = {
+    pattern: new RegExp(`(${addPortAndProtocolForIpv6(IPV6_PATTERN_BASE)})|(${addPortAndProtocol(DOMAIN_PATTERN_BASE)})`),
+    tip: 'regexp_tip_ipv6_address_or_hostname',
+};
+// include  ipv4, ipv6, domain, and support port and protocol
+export const IPV4_IPV6_ADDRESS_HOSTNAME_PORT_PATTERN = {
+    pattern: new RegExp(`(${addPortAndProtocol(IP_PATTERN_BASE)})|(${addPortAndProtocolForIpv6(IPV6_PATTERN_BASE)})|(${addPortAndProtocol(DOMAIN_PATTERN_BASE)})`),
+    tip: 'regexp_tip_ipv4_ipv6_address_or_hostname',
+};
+// include ipv4, ipv6, domain
+export const IP_ADDRESS_HOSTNAME_PATTERN_EXTEND = {
+    pattern: new RegExp(`(${IP_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})|(${IPV6_PATTERN_BASE})`),
+    tip: 'regexp_tip_ip_address_or_hostname',
+};
+export const IP_ADDRESS_SUBNET_PATTERN = {
+    pattern: /^((\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}(\d|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\/\d+$/,
+    tip: 'regexp_tip_ip_address_with_subnet',
+};
+export const DOMAIN_PATTERN = {
+    pattern: new RegExp(DOMAIN_PATTERN_BASE),
+    placeholder: 'domain_regexp_placeholder',
+    tip: 'domain_regexp_tip',
+};
+export const IP_ADDRESS_PATTERN = {
+    pattern: /^(?:(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d{1,2})$/,
+    placeholder: 'ip_address_placeholder',
+    tip: 'regexp_tip_ip_address',
+};
+export const IP_PATTERN = {
+    pattern: /^((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})){3}$/,
+    tip: 'invalid_ip',
+};
+export const IP_V6_PATTERN = {
+    pattern: new RegExp(`${IPV6_PATTERN_BASE}`),
+    tip: 'invalid_ip',
+};
+export const IP_V6_ADDRESS_PATTERN = {
+    pattern: new RegExp(IPV6_PATTERN_BASE),
+};
+export const IP_V4_OR_V6_PATTERN = {
+    pattern: new RegExp(`(${IP_PATTERN_BASE})|(${IPV6_PATTERN_BASE})`),
+};
+export const IP_ADDRESS_PORT_PATTERN = {
+    pattern: new RegExp(`${IP_PATTERN_BASE.slice(0, -1)}(?::\\d+)?$`),
+    tip: 'regexp_tip_ip_address',
+};
+export const INT_ZERO_PATTERN = {
+    pattern: /^(0|\+?[1-9]\d*)$/,
+    tip: 'regexp_tip_positive_integer_pattern_zero',
+};
+export const POSITIVE_INT_PATTERN = {
+    pattern: /^[1-9]\d*$/,
+    tip: 'regexp_tip_positive_integer_pattern',
+};
+export const POSITIVE_NUMBER_PATTERN = {
+    pattern: /^([1-9]\d*(?:\.\d*)?|0*\.0*[1-9]\d*)$/,
+    tip: 'regexp_tip_positive_number_pattern',
+};
+export const K8S_RESOURCE_NAME_BASE = {
+    pattern: /^[\da-z]([\da-z-]*[\da-z])?$/,
+    tip: 'regexp_tip_k8s_resource_name_base',
+};
+export const K8S_RESOURCE_LABEL_KEY_PREFIX_PATTERN = {
+    pattern: /^[\da-z]([\da-z-]*[\da-z])?(\.[\da-z]([\da-z-]*[\da-z])?)*$/,
+    tip: 'regexp_tip_resource_label_key_prefix',
+};
+// 不能直接用来校验 label key，需要使用 `k8sResourceLabelKeyValidator`
+export const K8S_RESOURCE_LABEL_KEY_NAME_PATTERN = {
+    pattern: /^(([\dA-Za-z][\w.-]*)?[\dA-Za-z])$/,
+    tip: 'k8s_resource_label_key_invalid',
+};
+export const K8S_RESOURCE_LABEL_VALUE_PATTERN = {
+    pattern: /^(([\dA-Za-z][\w.-]*)?[\dA-Za-z])?$/,
+    tip: 'k8s_resource_label_value_invalid',
+};
+export const K8S_RESOURCE_NAME_START_WITH_CHARS_ONLY = {
+    pattern: /^[a-z]([\da-z-]*[\da-z])?$/,
+    tip: 'regexp_tip_k8s_resource_name_start_with_chars_only',
+};
+export const HTTP_IP_OR_DOMAIN_PATTERN = {
+    pattern: /^((http|https):\/\/)((((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})){3})|((([\dA-Za-z-]*[\dA-Za-z])\.)*([A-Za-z]|[A-Za-z][\dA-Za-z-]*[\dA-Za-z])))(:(([1-9]\d{0,3})|([1-5]\d{4})|(6[0-4]\d{3})|(65[0-4]\d{2})|(655[0-2]\d)|(6553[0-5])))?(\/\S*)*$/,
+    tip: 'domain_ip_placeholder',
+};
+export const HTTP_DUAL_IP_OR_DOMAIN_PATTERN = {
+    pattern: /^((http|https):\/\/)((((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})(\.((2(5[0-5]|[0-4]\d))|[01]?\d{1,2})){3})|((([\dA-Za-z-]*[\dA-Za-z])\.)*([A-Za-z]|[A-Za-z][\dA-Za-z-]*[\dA-Za-z]))|(\[((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:)(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?\]))(:(([1-9]\d{0,3})|([1-5]\d{4})|(6[0-4]\d{3})|(65[0-4]\d{2})|(655[0-2]\d)|(6553[0-5])))?(\/\S*)*$/,
+    tip: 'domain_ip_placeholder',
+};
+export const HTTP_ADDRESS_PATTERN = {
+    pattern: /^(http|https):\/\/([\w.])\S*$/,
+    tip: 'http_address_format_limit',
+};
+export const EMAIL_PATTERN = {
+    pattern: /^[\w.-]+@[\w-]+(\.[\w-]+)+$/,
+    tip: 'invalid_email',
+};
+export const IMAGE_TAG_PATTERN = {
+    pattern: /^((sha256:[\da-f]{6,64})|(\w[\w.-]{0,127}))$/,
+    tip: 'regexp_tip_image_tag',
+    placeholder: 'image_tag_input_placeholder',
+};
+export const INT_PATTERN = {
+    pattern: /^-?\d+$/,
+    tip: 'regexp_tip_integer_pattern',
+};
+export const NUMBER_PATTERN = {
+    pattern: /^-?\d+(\.\d*)?$/,
+    tip: 'invalid_number',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"patterns.js","sourceRoot":"","sources":["../../../../../libs/dynamic-plugin-shared/src/constants/patterns.ts"],"names":[],"mappings":"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","sourcesContent":["export const DOMAIN_PATTERN_BASE = '^([\\\\da-z.-]+)\\\\.([a-z.]{2,6})$';\n\nexport const IP_PATTERN_BASE =\n  '^(?:(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})\\\\.){3}(?:25[0-5]|2[0-4]\\\\d|[01]?\\\\d{1,2})$';\n\nexport const IPV6_PATTERN_BASE =\n  '^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]+|::(ffff(:0{1,4})?:)?((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1?[0-9])?[0-9]).){3}(25[0-5]|(2[0-4]|1?[0-9])?[0-9]))$';\n\nconst PROTOCOL_PATTERN_BASE = 'https?://';\nconst PORT_PATTERN_BASE =\n  '(:(6553[0-5]|655[0-2]\\\\d|65[0-4]\\\\d\\\\d|6[0-4]\\\\d\\\\d\\\\d|[1-5]\\\\d\\\\d\\\\d\\\\d|[1-9]\\\\d\\\\d\\\\d|[1-9]\\\\d\\\\d|[1-9]\\\\d|[1-9]))';\n\nconst addPortAndProtocol = (patternStr: string) => {\n  const main = patternStr.replace(/(^\\^)?/, '').replace(/(\\$?)$/, '');\n  return `^(${PROTOCOL_PATTERN_BASE})?${main}(${PORT_PATTERN_BASE})?$`;\n};\n\nconst addPortAndProtocolForIpv6 = (patternStr: string) => {\n  const main = patternStr.replace(/(^\\^)?/, '').replace(/(\\$?)$/, '');\n  return `(${patternStr})|(^(${PROTOCOL_PATTERN_BASE})\\\\[${main}\\\\]$)|(^(${PROTOCOL_PATTERN_BASE})?\\\\[${main}\\\\](${PORT_PATTERN_BASE})$)`;\n};\n\nexport const PORT_PATTERN = {\n  pattern:\n    /(^[1-9]\\d{0,3}$)|(^[1-5]\\d{4}$)|^(6[0-4]\\d{3}$)|(^65[0-4]\\d{2}$)|(^655[0-2]\\d$)|(^6553[0-5]$)/,\n  tip: 'invalid_port',\n};\n\n// include ipv4, domain\nexport const IP_ADDRESS_HOSTNAME_PATTERN = {\n  pattern: new RegExp(`(${IP_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})`),\n  tip: 'regexp_tip_ip_address_or_hostname',\n};\n\n// include ipv6, domain\nexport const IPV6_ADDRESS_HOSTNAME_PATTERN = {\n  pattern: new RegExp(`(${IPV6_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})`),\n  tip: 'regexp_tip_ipv6_address_or_hostname',\n};\n\n// include ipv4, domain, and support port and protocol\nexport const IP_ADDRESS_HOSTNAME_PORT_PATTERN = {\n  pattern: new RegExp(\n    `(${addPortAndProtocol(IP_PATTERN_BASE)})|(${addPortAndProtocol(\n      DOMAIN_PATTERN_BASE,\n    )})`,\n  ),\n  tip: 'regexp_tip_ip_address_or_hostname',\n};\n\n// include ipv6, domain, and support port and protocol\nexport const IPV6_ADDRESS_HOSTNAME_PORT_PATTERN = {\n  pattern: new RegExp(\n    `(${addPortAndProtocolForIpv6(IPV6_PATTERN_BASE)})|(${addPortAndProtocol(\n      DOMAIN_PATTERN_BASE,\n    )})`,\n  ),\n  tip: 'regexp_tip_ipv6_address_or_hostname',\n};\n\n// include  ipv4, ipv6, domain, and support port and protocol\nexport const IPV4_IPV6_ADDRESS_HOSTNAME_PORT_PATTERN = {\n  pattern: new RegExp(\n    `(${addPortAndProtocol(IP_PATTERN_BASE)})|(${addPortAndProtocolForIpv6(\n      IPV6_PATTERN_BASE,\n    )})|(${addPortAndProtocol(DOMAIN_PATTERN_BASE)})`,\n  ),\n  tip: 'regexp_tip_ipv4_ipv6_address_or_hostname',\n};\n\n// include ipv4, ipv6, domain\nexport const IP_ADDRESS_HOSTNAME_PATTERN_EXTEND = {\n  pattern: new RegExp(\n    `(${IP_PATTERN_BASE})|(${DOMAIN_PATTERN_BASE})|(${IPV6_PATTERN_BASE})`,\n  ),\n  tip: 'regexp_tip_ip_address_or_hostname',\n};\n\nexport const IP_ADDRESS_SUBNET_PATTERN = {\n  pattern:\n    /^((\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\.){3}(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])\\/\\d+$/,\n  tip: 'regexp_tip_ip_address_with_subnet',\n};\n\nexport const DOMAIN_PATTERN = {\n  pattern: new RegExp(DOMAIN_PATTERN_BASE),\n  placeholder: 'domain_regexp_placeholder',\n  tip: 'domain_regexp_tip',\n};\n\nexport const IP_ADDRESS_PATTERN = {\n  pattern:\n    /^(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d{1,2})$/,\n  placeholder: 'ip_address_placeholder',\n  tip: 'regexp_tip_ip_address',\n};\n\nexport const IP_PATTERN = {\n  pattern:\n    /^((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})(\\.((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})){3}$/,\n  tip: 'invalid_ip',\n};\n\nexport const IP_V6_PATTERN = {\n  pattern: new RegExp(`${IPV6_PATTERN_BASE}`),\n  tip: 'invalid_ip',\n};\n\nexport const IP_V6_ADDRESS_PATTERN = {\n  pattern: new RegExp(IPV6_PATTERN_BASE),\n};\n\nexport const IP_V4_OR_V6_PATTERN = {\n  pattern: new RegExp(`(${IP_PATTERN_BASE})|(${IPV6_PATTERN_BASE})`),\n};\n\nexport const IP_ADDRESS_PORT_PATTERN = {\n  pattern: new RegExp(`${IP_PATTERN_BASE.slice(0, -1)}(?::\\\\d+)?$`),\n  tip: 'regexp_tip_ip_address',\n};\n\nexport const INT_ZERO_PATTERN = {\n  pattern: /^(0|\\+?[1-9]\\d*)$/,\n  tip: 'regexp_tip_positive_integer_pattern_zero',\n};\n\nexport const POSITIVE_INT_PATTERN = {\n  pattern: /^[1-9]\\d*$/,\n  tip: 'regexp_tip_positive_integer_pattern',\n};\n\nexport const POSITIVE_NUMBER_PATTERN = {\n  pattern: /^([1-9]\\d*(?:\\.\\d*)?|0*\\.0*[1-9]\\d*)$/,\n  tip: 'regexp_tip_positive_number_pattern',\n};\n\nexport const K8S_RESOURCE_NAME_BASE = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?$/,\n  tip: 'regexp_tip_k8s_resource_name_base',\n};\n\nexport const K8S_RESOURCE_LABEL_KEY_PREFIX_PATTERN = {\n  pattern: /^[\\da-z]([\\da-z-]*[\\da-z])?(\\.[\\da-z]([\\da-z-]*[\\da-z])?)*$/,\n  tip: 'regexp_tip_resource_label_key_prefix',\n};\n\n// 不能直接用来校验 label key，需要使用 `k8sResourceLabelKeyValidator`\nexport const K8S_RESOURCE_LABEL_KEY_NAME_PATTERN = {\n  pattern: /^(([\\dA-Za-z][\\w.-]*)?[\\dA-Za-z])$/,\n  tip: 'k8s_resource_label_key_invalid',\n};\n\nexport const K8S_RESOURCE_LABEL_VALUE_PATTERN = {\n  pattern: /^(([\\dA-Za-z][\\w.-]*)?[\\dA-Za-z])?$/,\n  tip: 'k8s_resource_label_value_invalid',\n};\n\nexport const K8S_RESOURCE_NAME_START_WITH_CHARS_ONLY = {\n  pattern: /^[a-z]([\\da-z-]*[\\da-z])?$/,\n  tip: 'regexp_tip_k8s_resource_name_start_with_chars_only',\n};\n\nexport const HTTP_IP_OR_DOMAIN_PATTERN = {\n  pattern:\n    /^((http|https):\\/\\/)((((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})(\\.((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})){3})|((([\\dA-Za-z-]*[\\dA-Za-z])\\.)*([A-Za-z]|[A-Za-z][\\dA-Za-z-]*[\\dA-Za-z])))(:(([1-9]\\d{0,3})|([1-5]\\d{4})|(6[0-4]\\d{3})|(65[0-4]\\d{2})|(655[0-2]\\d)|(6553[0-5])))?(\\/\\S*)*$/,\n  tip: 'domain_ip_placeholder',\n};\n\nexport const HTTP_DUAL_IP_OR_DOMAIN_PATTERN = {\n  pattern:\n    /^((http|https):\\/\\/)((((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})(\\.((2(5[0-5]|[0-4]\\d))|[01]?\\d{1,2})){3})|((([\\dA-Za-z-]*[\\dA-Za-z])\\.)*([A-Za-z]|[A-Za-z][\\dA-Za-z-]*[\\dA-Za-z]))|(\\[((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:)(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)(\\.(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)){3}))|:)))(%.+)?\\]))(:(([1-9]\\d{0,3})|([1-5]\\d{4})|(6[0-4]\\d{3})|(65[0-4]\\d{2})|(655[0-2]\\d)|(6553[0-5])))?(\\/\\S*)*$/,\n  tip: 'domain_ip_placeholder',\n};\n\nexport const HTTP_ADDRESS_PATTERN = {\n  pattern: /^(http|https):\\/\\/([\\w.])\\S*$/,\n  tip: 'http_address_format_limit',\n};\n\nexport const EMAIL_PATTERN = {\n  pattern: /^[\\w.-]+@[\\w-]+(\\.[\\w-]+)+$/,\n  tip: 'invalid_email',\n};\n\nexport const IMAGE_TAG_PATTERN = {\n  pattern: /^((sha256:[\\da-f]{6,64})|(\\w[\\w.-]{0,127}))$/,\n  tip: 'regexp_tip_image_tag',\n  placeholder: 'image_tag_input_placeholder',\n};\n\nexport const INT_PATTERN = {\n  pattern: /^-?\\d+$/,\n  tip: 'regexp_tip_integer_pattern',\n};\n\nexport const NUMBER_PATTERN = {\n  pattern: /^-?\\d+(\\.\\d*)?$/,\n  tip: 'invalid_number',\n};\n"]}