@alauda-fe/crd-form 0.0.1

package/esm2022/lib/field-controls/widgets/utils.mjs

@@ -0,0 +1,73 @@
+import { parseJson } from '@alauda-fe/common';
+import { escapeRegExp } from 'lodash-es';
+import { SpecCapability } from '../../types';
+function getConfigurations(specCapability, part) {
+    const regExp = new RegExp(`^${escapeRegExp(part)}(.*)$`);
+    const [_, config] = regExp.exec(specCapability) || [];
+    return config;
+}
+// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required
+// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required:limit-memory&limit-cpu&request-memory&request-cpu
+// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required:limit&request-memory
+export function resolveRequirementsRequiredOptions(field) {
+    if (!field) {
+        return null;
+    }
+    const options = field.capabilities.filter(descriptor => descriptor.startsWith(SpecCapability.resourceRequirements));
+    const allRequired = options.includes(`${SpecCapability.resourceRequirements}:required`);
+    if (allRequired) {
+        return {
+            required: {
+                limit: ['cpu', 'memory'],
+                request: ['cpu', 'memory'],
+            },
+        };
+    }
+    const requiredMap = options.reduce((prev, curr) => {
+        const partsStr = curr.split(`${SpecCapability.resourceRequirements}:required:`)?.[1];
+        partsStr?.split('&')?.forEach(optionStr => {
+            const options = optionStr?.split('-');
+            if (options.length === 1) {
+                prev[options[0]].add('memory').add('cpu');
+            }
+            if (options.length > 1) {
+                prev[options[0]].add(options[1]);
+            }
+        });
+        return prev;
+    }, {
+        limit: new Set(),
+        request: new Set(),
+    });
+    return {
+        required: {
+            limit: Array.from(requiredMap.limit),
+            request: Array.from(requiredMap.request),
+        },
+    };
+}
+// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:min:{"limits": {"cpu":"2c", "memory":"500Mi"}, "requests":{"cpu":"100m", "memory":"250Mi"}}
+// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:max:{"limits": {"cpu":"4c", "memory":"500Mi"}, "requests":{"cpu":"4c", "memory":"500Mi"}}
+export function resolveRequirementsMinOrMaxOptions(field) {
+    if (!field) {
+        return null;
+    }
+    const options = field.capabilities.filter(descriptor => descriptor.startsWith(SpecCapability.resourceRequirements));
+    const getConfigurationMap = (option, capability) => {
+        const configuration = getConfigurations(option, capability);
+        const { limits, requests } = parseJson(configuration, {
+            limits: { cpu: null, memory: null },
+            requests: { cpu: null, memory: null },
+        });
+        return { limits, requests };
+    };
+    const getResourceMinOrMaxMap = (suffix) => {
+        const option = options.find(option => option.includes(`${SpecCapability.resourceRequirements}:${suffix}:`));
+        return getConfigurationMap(option, `${SpecCapability.resourceRequirements}:${suffix}:`);
+    };
+    return {
+        min: getResourceMinOrMaxMap('min'),
+        max: getResourceMinOrMaxMap('max'),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../../../../libs/crd-form/src/lib/field-controls/widgets/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { parseJson } from '@alauda-fe/common';\nimport { escapeRegExp } from 'lodash-es';\n\nimport { OperandField, SpecCapability } from '../../types';\n\nfunction getConfigurations(specCapability: string, part: string) {\n  const regExp = new RegExp(`^${escapeRegExp(part)}(.*)$`);\n  const [_, config] = regExp.exec(specCapability) || [];\n  return config;\n}\n\n// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required\n// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required:limit-memory&limit-cpu&request-memory&request-cpu\n// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:required:limit&request-memory\nexport function resolveRequirementsRequiredOptions(field: OperandField) {\n  if (!field) {\n    return null;\n  }\n  const options = field.capabilities.filter(descriptor =>\n    descriptor.startsWith(SpecCapability.resourceRequirements),\n  ) as string[];\n  const allRequired = options.includes(\n    `${SpecCapability.resourceRequirements}:required`,\n  );\n  if (allRequired) {\n    return {\n      required: {\n        limit: ['cpu', 'memory'],\n        request: ['cpu', 'memory'],\n      },\n    };\n  }\n  const requiredMap = options.reduce(\n    (prev, curr) => {\n      const partsStr = curr.split(\n        `${SpecCapability.resourceRequirements}:required:`,\n      )?.[1];\n      partsStr?.split('&')?.forEach(optionStr => {\n        const options = optionStr?.split('-');\n        if (options.length === 1) {\n          prev[options[0] as 'limit' | 'request'].add('memory').add('cpu');\n        }\n        if (options.length > 1) {\n          prev[options[0] as 'limit' | 'request'].add(options[1]);\n        }\n      });\n      return prev;\n    },\n    {\n      limit: new Set<string>(),\n      request: new Set<string>(),\n    },\n  );\n\n  return {\n    required: {\n      limit: Array.from(requiredMap.limit),\n      request: Array.from(requiredMap.request),\n    },\n  };\n}\n\n// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:min:{\"limits\": {\"cpu\":\"2c\", \"memory\":\"500Mi\"}, \"requests\":{\"cpu\":\"100m\", \"memory\":\"250Mi\"}}\n// urn:alm:descriptor:com.tectonic.ui:resourceRequirements:max:{\"limits\": {\"cpu\":\"4c\", \"memory\":\"500Mi\"}, \"requests\":{\"cpu\":\"4c\", \"memory\":\"500Mi\"}}\nexport function resolveRequirementsMinOrMaxOptions(field: OperandField) {\n  if (!field) {\n    return null;\n  }\n\n  const options = field.capabilities.filter(descriptor =>\n    descriptor.startsWith(SpecCapability.resourceRequirements),\n  ) as string[];\n\n  const getConfigurationMap = (option: string, capability: string) => {\n    const configuration = getConfigurations(option, capability);\n    const { limits, requests } = parseJson<{\n      limits: { cpu: string; memory: string };\n      requests: { cpu: string; memory: string };\n    }>(configuration, {\n      limits: { cpu: null, memory: null },\n      requests: { cpu: null, memory: null },\n    });\n\n    return { limits, requests };\n  };\n\n  const getResourceMinOrMaxMap = (suffix: string) => {\n    const option = options.find(option =>\n      option.includes(`${SpecCapability.resourceRequirements}:${suffix}:`),\n    );\n    return getConfigurationMap(\n      option,\n      `${SpecCapability.resourceRequirements}:${suffix}:`,\n    );\n  };\n\n  return {\n    min: getResourceMinOrMaxMap('min'),\n    max: getResourceMinOrMaxMap('max'),\n  };\n}\n"]}

package/esm2022/lib/field-controls/widgets/yaml-editor/yaml-editor.component.mjs

@@ -0,0 +1,94 @@
+import { stringify, parse } from '@alauda-fe/common';
+import { ChangeDetectionStrategy, Component, Injector, Input, } from '@angular/core';
+import { BaseResourceFormGroupComponent } from 'ng-resource-form-util';
+import { SpecCapability } from '../../../types';
+import { OperandFieldComponent } from '../../operand-field.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../operand-field.component";
+import * as i2 from "@angular/forms";
+import * as i3 from "@alauda/ui";
+import * as i4 from "@alauda/code-editor";
+import * as i5 from "@alauda-fe/common";
+export class YamlEditorComponent extends BaseResourceFormGroupComponent {
+    constructor(injector, fieldComponent) {
+        super(injector);
+        this.fieldComponent = fieldComponent;
+        this.disabledActionsConfig = {};
+        this.resultFormat = 'json';
+        this.disabledActionsConfig = this.getDisabledActionsConfig(this.fieldComponent?.field);
+        this.resultFormat = this.getResultFormat(this.fieldComponent?.field);
+    }
+    getResultFormat(field) {
+        return (field?.capabilities
+            .find(c => c.startsWith(SpecCapability.yamlResult))
+            ?.split(SpecCapability.yamlResult)?.[1] || 'json');
+    }
+    createForm() {
+        return this.fb.group({
+            yaml: null,
+        });
+    }
+    getDisabledActionsConfig(field) {
+        const disabledActions = field?.capabilities
+            .find(c => c.startsWith(SpecCapability.yamlActionsDisabled))
+            ?.split(SpecCapability.yamlActionsDisabled)?.[1]
+            ?.split(',') || [];
+        return disabledActions.reduce((acc, cur) => ({ ...acc, [cur]: false }), {});
+    }
+    adaptResourceModel(resource) {
+        try {
+            return {
+                yaml: resource
+                    ? stringify(this.resultFormat === 'json'
+                        ? resource
+                        : JSON.parse(resource))
+                    : '',
+            };
+        }
+        catch (e) {
+            console.error(e);
+            return {
+                yaml: '',
+            };
+        }
+    }
+    adaptFormModel(formModel) {
+        try {
+            const parsedYaml = parse(formModel.yaml);
+            return this.resultFormat === 'json'
+                ? parsedYaml
+                : parsedYaml
+                    ? JSON.stringify(parsedYaml)
+                    : '';
+        }
+        catch { }
+        return null;
+    }
+    getActionsConfig(defaultActions, disabledActions) {
+        return {
+            ...defaultActions,
+            ...disabledActions,
+        };
+    }
+    static { this.ɵfac = function YamlEditorComponent_Factory(t) { return new (t || YamlEditorComponent)(i0.ɵɵdirectiveInject(i0.Injector), i0.ɵɵdirectiveInject(i1.OperandFieldComponent)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: YamlEditorComponent, selectors: [["acl-crd-yaml-editor"]], inputs: { actionsConfig: "actionsConfig", options: "options" }, features: [i0.ɵɵInheritDefinitionFeature], decls: 3, vars: 7, consts: [["aui-form", "", 3, "formGroup"], ["auiFormItemControl", "", "formControlName", "yaml", 3, "actionsConfig", "options"]], template: function YamlEditorComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementStart(0, "form", 0);
+            i0.ɵɵelement(1, "aui-code-editor", 1);
+            i0.ɵɵpipe(2, "pure");
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("formGroup", ctx.form);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("actionsConfig", i0.ɵɵpipeBind3(2, 3, ctx.actionsConfig, ctx.getActionsConfig, ctx.disabledActionsConfig))("options", ctx.options);
+        } }, dependencies: [i2.ɵNgNoValidate, i2.NgControlStatus, i2.NgControlStatusGroup, i2.FormGroupDirective, i2.FormControlName, i3.FormItemControlDirective, i4.CodeEditorComponent, i5.PurePipe], styles: ["[_nghost-%COMP%]{width:100%}[_nghost-%COMP%]   form[_ngcontent-%COMP%]{width:100%}"], changeDetection: 0 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(YamlEditorComponent, [{
+        type: Component,
+        args: [{ selector: 'acl-crd-yaml-editor', changeDetection: ChangeDetectionStrategy.OnPush, template: "<form\n  aui-form\n  [formGroup]=\"form\"\n>\n  <aui-code-editor\n    auiFormItemControl\n    formControlName=\"yaml\"\n    [actionsConfig]=\"\n      actionsConfig | pure: getActionsConfig:disabledActionsConfig\n    \"\n    [options]=\"options\"\n  ></aui-code-editor>\n</form>\n", styles: [":host{width:100%}:host form{width:100%}\n"] }]
+    }], () => [{ type: i0.Injector }, { type: i1.OperandFieldComponent }], { actionsConfig: [{
+            type: Input
+        }], options: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(YamlEditorComponent, { className: "YamlEditorComponent", filePath: "lib/field-controls/widgets/yaml-editor/yaml-editor.component.ts", lineNumber: 27 }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/field-widgets/htpasswd/component.mjs

@@ -0,0 +1,35 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { OperandFieldComponent } from '../../field-controls';
+import * as i0 from "@angular/core";
+import * as i1 from "../../field-controls";
+import * as i2 from "@angular/forms";
+import * as i3 from "@alauda-fe/common";
+import * as i4 from "./form";
+export class HtpasswdComponent {
+    constructor(fieldComponent) {
+        this.fieldComponent = fieldComponent;
+        this.isUpdate =
+            !!fieldComponent.control.value && !fieldComponent.control.dirty;
+    }
+    static { this.ɵfac = function HtpasswdComponent_Factory(t) { return new (t || HtpasswdComponent)(i0.ɵɵdirectiveInject(i1.OperandFieldComponent)); }; }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: HtpasswdComponent, selectors: [["ng-component"]], decls: 1, vars: 5, consts: [[3, "hidden", "formControl", "field", "required", "isUpdate"]], template: function HtpasswdComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelement(0, "acl-htpasswd-form", 0);
+        } if (rf & 2) {
+            i0.ɵɵproperty("hidden", ctx.fieldComponent.isDisabled)("formControl", ctx.fieldComponent.control)("field", ctx.fieldComponent.field)("required", ctx.fieldComponent.isRequired)("isUpdate", ctx.isUpdate);
+        } }, dependencies: [i2.NgControlStatus, i2.RequiredValidator, i2.FormControlDirective, i3.ValidatorsDirective, i4.HtpasswdFormComponent], encapsulation: 2, changeDetection: 0 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HtpasswdComponent, [{
+        type: Component,
+        args: [{
+                template: `<acl-htpasswd-form
+    [hidden]="fieldComponent.isDisabled"
+    [formControl]="fieldComponent.control"
+    [field]="fieldComponent.field"
+    [required]="fieldComponent.isRequired"
+    [isUpdate]="isUpdate"
+  ></acl-htpasswd-form>`,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], () => [{ type: i1.OperandFieldComponent }], null); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(HtpasswdComponent, { className: "HtpasswdComponent", filePath: "lib/field-widgets/htpasswd/component.ts", lineNumber: 15 }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jcmQtZm9ybS9zcmMvbGliL2ZpZWxkLXdpZGdldHMvaHRwYXNzd2QvY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFbkUsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sc0JBQXNCLENBQUM7Ozs7OztBQVk3RCxNQUFNLE9BQU8saUJBQWlCO0lBRzVCLFlBQW1CLGNBQXFDO1FBQXJDLG1CQUFjLEdBQWQsY0FBYyxDQUF1QjtRQUN0RCxJQUFJLENBQUMsUUFBUTtZQUNYLENBQUMsQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLEtBQUssSUFBSSxDQUFDLGNBQWMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO0lBQ3BFLENBQUM7a0ZBTlUsaUJBQWlCO29FQUFqQixpQkFBaUI7WUFUakIsdUNBTVU7O1lBRG5CLEFBREEsQUFEQSxBQURBLEFBREEsc0RBQW9DLDJDQUNFLG1DQUNSLDJDQUNRLDBCQUNqQjs7O2lGQUlaLGlCQUFpQjtjQVY3QixTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFOzs7Ozs7d0JBTVk7Z0JBQ3RCLGVBQWUsRUFBRSx1QkFBdUIsQ0FBQyxNQUFNO2FBQ2hEOztrRkFDWSxpQkFBaUIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSwgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE9wZXJhbmRGaWVsZENvbXBvbmVudCB9IGZyb20gJy4uLy4uL2ZpZWxkLWNvbnRyb2xzJztcblxuQENvbXBvbmVudCh7XG4gIHRlbXBsYXRlOiBgPGFjbC1odHBhc3N3ZC1mb3JtXG4gICAgW2hpZGRlbl09XCJmaWVsZENvbXBvbmVudC5pc0Rpc2FibGVkXCJcbiAgICBbZm9ybUNvbnRyb2xdPVwiZmllbGRDb21wb25lbnQuY29udHJvbFwiXG4gICAgW2ZpZWxkXT1cImZpZWxkQ29tcG9uZW50LmZpZWxkXCJcbiAgICBbcmVxdWlyZWRdPVwiZmllbGRDb21wb25lbnQuaXNSZXF1aXJlZFwiXG4gICAgW2lzVXBkYXRlXT1cImlzVXBkYXRlXCJcbiAgPjwvYWNsLWh0cGFzc3dkLWZvcm0+YCxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG59KVxuZXhwb3J0IGNsYXNzIEh0cGFzc3dkQ29tcG9uZW50IHtcbiAgaXNVcGRhdGU6IGJvb2xlYW47XG5cbiAgY29uc3RydWN0b3IocHVibGljIGZpZWxkQ29tcG9uZW50OiBPcGVyYW5kRmllbGRDb21wb25lbnQpIHtcbiAgICB0aGlzLmlzVXBkYXRlID1cbiAgICAgICEhZmllbGRDb21wb25lbnQuY29udHJvbC52YWx1ZSAmJiAhZmllbGRDb21wb25lbnQuY29udHJvbC5kaXJ0eTtcbiAgfVxufVxuIl19

package/esm2022/lib/field-widgets/htpasswd/form.mjs

@@ -0,0 +1,171 @@
+import { ChangeDetectionStrategy, Component, Input } from '@angular/core';
+import { hashSync } from 'bcryptjs';
+import { BaseResourceFormComponent } from 'ng-resource-form-util';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@alauda/ui";
+import * as i4 from "@alauda-fe/common";
+function HtpasswdFormComponent_aui_form_item_1_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-form-item", 4)(1, "label", 5);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(3, "input", 6)(4, "div", 7, 0);
+    i0.ɵɵelementStart(6, "div", 8);
+    i0.ɵɵtext(7);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const label_r1 = ctx.ngIf;
+    const usernameError_r2 = i0.ɵɵreference(5);
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(label_r1);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("required", ctx_r2.required)("aclErrorsMapperOutlet", usernameError_r2);
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(label_r1);
+} }
+function HtpasswdFormComponent_aui_form_item_4_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelementStart(0, "aui-form-item", 4)(1, "label", 5);
+    i0.ɵɵtext(2);
+    i0.ɵɵelementEnd();
+    i0.ɵɵelement(3, "input", 9)(4, "div", 7, 1);
+    i0.ɵɵelementStart(6, "div", 8);
+    i0.ɵɵtext(7);
+    i0.ɵɵelementEnd()();
+} if (rf & 2) {
+    const label_r4 = ctx.ngIf;
+    const passwordError_r5 = i0.ɵɵreference(5);
+    const ctx_r2 = i0.ɵɵnextContext();
+    i0.ɵɵadvance(2);
+    i0.ɵɵtextInterpolate(label_r4);
+    i0.ɵɵadvance();
+    i0.ɵɵproperty("required", (!ctx_r2.isUpdate || ctx_r2.originalUsername !== ctx_r2.form.get("username").value) && ctx_r2.required)("aclErrorsMapperOutlet", passwordError_r5);
+    i0.ɵɵadvance(4);
+    i0.ɵɵtextInterpolate(label_r4);
+} }
+export class HtpasswdFormComponent extends BaseResourceFormComponent {
+    constructor() {
+        super(...arguments);
+        // `null` is required because the default value is `null`,
+        // if it is `undefined` here, it will cause form value change event unexpectedly...
+        this.originalResource = null;
+    }
+    createForm() {
+        return this.fb.group({
+            username: '',
+            password: '',
+        });
+    }
+    adaptResourceModel(resource) {
+        let username = '';
+        if (resource) {
+            const parts = resource.split(':');
+            parts.pop();
+            username = parts.join(':');
+            if (!this.originalUsername) {
+                this.originalUsername = username;
+                this.originalResource = resource;
+            }
+        }
+        return {
+            username,
+            password: '',
+        };
+    }
+    adaptFormModel({ username, password, }) {
+        if (!username || !password || !this.form.get('password').dirty) {
+            return this.originalResource;
+        }
+        return [username, hashSync(password)].join(':');
+    }
+    getLabel(field, type) {
+        const capabilities = field.capabilities;
+        const enCapability = `urn:alm:descriptor:${type}:label:en:`;
+        const zhCapability = `urn:alm:descriptor:${type}:label:zh:`;
+        const en = capabilities
+            ?.find(c => c.startsWith(enCapability))
+            ?.split(enCapability)[1];
+        const zh = capabilities
+            ?.find(c => c.startsWith(zhCapability))
+            ?.split(zhCapability)[1];
+        return zh ? { en, zh } : type;
+    }
+    static { this.ɵfac = /*@__PURE__*/ (() => { let ɵHtpasswdFormComponent_BaseFactory; return function HtpasswdFormComponent_Factory(t) { return (ɵHtpasswdFormComponent_BaseFactory || (ɵHtpasswdFormComponent_BaseFactory = i0.ɵɵgetInheritedFactory(HtpasswdFormComponent)))(t || HtpasswdFormComponent); }; })(); }
+    static { this.ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: HtpasswdFormComponent, selectors: [["acl-htpasswd-form"]], inputs: { field: "field", required: "required", isUpdate: "isUpdate" }, features: [i0.ɵɵInheritDefinitionFeature], decls: 7, vars: 15, consts: [["usernameError", ""], ["passwordError", ""], [3, "formGroup"], ["width", "large", 4, "ngIf"], ["width", "large"], ["auiFormItemLabel", ""], ["aui-input", "", "auiFormItemControl", "", "formControlName", "username", "aclErrorsMapper", "", 3, "required", "aclErrorsMapperOutlet"], ["auiFormItemError", ""], ["auiFormItemHint", ""], ["aui-input", "", "type", "password", "auiFormItemControl", "", "formControlName", "password", "aclStrongPassword", "", "aclErrorsMapper", "", 3, "required", "aclErrorsMapperOutlet"]], template: function HtpasswdFormComponent_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵelementContainerStart(0, 2);
+            i0.ɵɵtemplate(1, HtpasswdFormComponent_aui_form_item_1_Template, 8, 4, "aui-form-item", 3);
+            i0.ɵɵpipe(2, "pure");
+            i0.ɵɵpipe(3, "translate");
+            i0.ɵɵtemplate(4, HtpasswdFormComponent_aui_form_item_4_Template, 8, 4, "aui-form-item", 3);
+            i0.ɵɵpipe(5, "pure");
+            i0.ɵɵpipe(6, "translate");
+            i0.ɵɵelementContainerEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("formGroup", ctx.form);
+            i0.ɵɵadvance();
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(3, 7, i0.ɵɵpipeBind3(2, 3, ctx.field, ctx.getLabel, "username")));
+            i0.ɵɵadvance(3);
+            i0.ɵɵproperty("ngIf", i0.ɵɵpipeBind1(6, 13, i0.ɵɵpipeBind3(5, 9, ctx.field, ctx.getLabel, "password")));
+        } }, dependencies: [i1.NgIf, i2.DefaultValueAccessor, i2.NgControlStatus, i2.NgControlStatusGroup, i2.RequiredValidator, i2.FormGroupDirective, i2.FormControlName, i3.FormItemComponent, i3.FormItemErrorDirective, i3.FormItemHintDirective, i3.FormItemLabelDirective, i3.FormItemControlDirective, i3.InputComponent, i4.ErrorsMapperDirective, i4.StrongPasswordDirective, i4.ValidatorsDirective, i4.TranslatePipe, i4.PurePipe], encapsulation: 2, changeDetection: 0 }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HtpasswdFormComponent, [{
+        type: Component,
+        args: [{
+                selector: 'acl-htpasswd-form',
+                template: `<ng-container [formGroup]="form">
+    <aui-form-item
+      width="large"
+      *ngIf="field | pure: getLabel:'username' | translate as label"
+    >
+      <label auiFormItemLabel>{{ label }}</label>
+      <input
+        aui-input
+        auiFormItemControl
+        formControlName="username"
+        [required]="required"
+        aclErrorsMapper
+        [aclErrorsMapperOutlet]="usernameError"
+      />
+      <div
+        #usernameError
+        auiFormItemError
+      ></div>
+      <div auiFormItemHint>{{ label }}</div>
+    </aui-form-item>
+    <aui-form-item
+      width="large"
+      *ngIf="field | pure: getLabel:'password' | translate as label"
+    >
+      <label auiFormItemLabel>{{ label }}</label>
+      <input
+        aui-input
+        type="password"
+        auiFormItemControl
+        formControlName="password"
+        [required]="
+          (!isUpdate || originalUsername !== form.get('username').value) &&
+          required
+        "
+        aclStrongPassword
+        aclErrorsMapper
+        [aclErrorsMapperOutlet]="passwordError"
+      />
+      <div
+        #passwordError
+        auiFormItemError
+      ></div>
+      <div auiFormItemHint>{{ label }}</div>
+    </aui-form-item>
+  </ng-container> `,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+            }]
+    }], null, { field: [{
+            type: Input
+        }], required: [{
+            type: Input
+        }], isUpdate: [{
+            type: Input
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(HtpasswdFormComponent, { className: "HtpasswdFormComponent", filePath: "lib/field-widgets/htpasswd/form.ts", lineNumber: 57 }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form.js","sourceRoot":"","sources":["../../../../../../../libs/crd-form/src/lib/field-widgets/htpasswd/form.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAE1E,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AACpC,OAAO,EAAE,yBAAyB,EAAE,MAAM,uBAAuB,CAAC;;;;;;;IAW5D,AAJF,wCAGC,eACyB;IAAA,YAAW;IAAA,iBAAQ;IAS3C,AARA,2BAOE,gBAIK;IACP,8BAAqB;IAAA,YAAW;IAClC,AADkC,iBAAM,EACxB;;;;;IAdU,eAAW;IAAX,8BAAW;IAKjC,cAAqB;IAErB,AAFA,0CAAqB,2CAEkB;IAMpB,eAAW;IAAX,8BAAW;;;IAMhC,AAJF,wCAGC,eACyB;IAAA,YAAW;IAAA,iBAAQ;IAc3C,AAbA,2BAYE,gBAIK;IACP,8BAAqB;IAAA,YAAW;IAClC,AADkC,iBAAM,EACxB;;;;;IAnBU,eAAW;IAAX,8BAAW;IAMjC,cAGC;IAGD,AANA,iIAGC,2CAGsC;IAMpB,eAAW;IAAX,8BAAW;;AAKtC,MAAM,OAAO,qBAAsB,SAAQ,yBAI1C;IArDD;;QAgEE,0DAA0D;QAC1D,mFAAmF;QACnF,qBAAgB,GAAW,IAAI,CAAC;KAwDjC;IAtDC,UAAU;QACR,OAAO,IAAI,CAAC,EAAE,CAAC,KAAK,CAAC;YACnB,QAAQ,EAAE,EAAE;YACZ,QAAQ,EAAE,EAAE;SACb,CAAC,CAAC;IACL,CAAC;IAEQ,kBAAkB,CAAC,QAAgB;QAI1C,IAAI,QAAQ,GAAG,EAAE,CAAC;QAClB,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YAClC,KAAK,CAAC,GAAG,EAAE,CAAC;YACZ,QAAQ,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC3B,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBAC3B,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;gBACjC,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC;YACnC,CAAC;QACH,CAAC;QAED,OAAO;YACL,QAAQ;YACR,QAAQ,EAAE,EAAE;SACb,CAAC;IACJ,CAAC;IAEQ,cAAc,CAAC,EACtB,QAAQ,EACR,QAAQ,GAIT;QACC,IAAI,CAAC,QAAQ,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,KAAK,EAAE,CAAC;YAC/D,OAAO,IAAI,CAAC,gBAAgB,CAAC;QAC/B,CAAC;QAED,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClD,CAAC;IAED,QAAQ,CAAC,KAAmB,EAAE,IAA6B;QACzD,MAAM,YAAY,GAAG,KAAK,CAAC,YAAY,CAAC;QACxC,MAAM,YAAY,GAAG,sBAAsB,IAAI,YAAY,CAAC;QAC5D,MAAM,YAAY,GAAG,sBAAsB,IAAI,YAAY,CAAC;QAC5D,MAAM,EAAE,GAAG,YAAY;YACrB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;YACvC,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,MAAM,EAAE,GAAG,YAAY;YACrB,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;YACvC,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAChC,CAAC;wPAxEU,qBAAqB,SAArB,qBAAqB;oEAArB,qBAAqB;YA/CrB,gCAAiC;YAC1C,0FAGC;;;YAgBD,0FAGC;;;;;YAvBsB,oCAAkB;YAGtC,cAAoD;YAApD,sGAAoD;YAmBpD,eAAoD;YAApD,uGAAoD;;;iFAyB9C,qBAAqB;cAjDjC,SAAS;eAAC;gBACT,QAAQ,EAAE,mBAAmB;gBAC7B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBA4CO;gBACjB,eAAe,EAAE,uBAAuB,CAAC,MAAM;aAChD;gBAOC,KAAK;kBADJ,KAAK;YAIN,QAAQ;kBADP,KAAK;YAIN,QAAQ;kBADP,KAAK;;kFAXK,qBAAqB","sourcesContent":["import { ChangeDetectionStrategy, Component, Input } from '@angular/core';\nimport { FormGroup } from '@angular/forms';\nimport { hashSync } from 'bcryptjs';\nimport { BaseResourceFormComponent } from 'ng-resource-form-util';\n\nimport { OperandField } from '../../types';\n\n@Component({\n  selector: 'acl-htpasswd-form',\n  template: `<ng-container [formGroup]=\"form\">\n    <aui-form-item\n      width=\"large\"\n      *ngIf=\"field | pure: getLabel:'username' | translate as label\"\n    >\n      <label auiFormItemLabel>{{ label }}</label>\n      <input\n        aui-input\n        auiFormItemControl\n        formControlName=\"username\"\n        [required]=\"required\"\n        aclErrorsMapper\n        [aclErrorsMapperOutlet]=\"usernameError\"\n      />\n      <div\n        #usernameError\n        auiFormItemError\n      ></div>\n      <div auiFormItemHint>{{ label }}</div>\n    </aui-form-item>\n    <aui-form-item\n      width=\"large\"\n      *ngIf=\"field | pure: getLabel:'password' | translate as label\"\n    >\n      <label auiFormItemLabel>{{ label }}</label>\n      <input\n        aui-input\n        type=\"password\"\n        auiFormItemControl\n        formControlName=\"password\"\n        [required]=\"\n          (!isUpdate || originalUsername !== form.get('username').value) &&\n          required\n        \"\n        aclStrongPassword\n        aclErrorsMapper\n        [aclErrorsMapperOutlet]=\"passwordError\"\n      />\n      <div\n        #passwordError\n        auiFormItemError\n      ></div>\n      <div auiFormItemHint>{{ label }}</div>\n    </aui-form-item>\n  </ng-container> `,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class HtpasswdFormComponent extends BaseResourceFormComponent<\n  string,\n  { username: string; password: string },\n  FormGroup\n> {\n  @Input()\n  field: OperandField;\n\n  @Input()\n  required: boolean;\n\n  @Input()\n  isUpdate: boolean;\n\n  originalUsername: string;\n  // `null` is required because the default value is `null`,\n  // if it is `undefined` here, it will cause form value change event unexpectedly...\n  originalResource: string = null;\n\n  createForm() {\n    return this.fb.group({\n      username: '',\n      password: '',\n    });\n  }\n\n  override adaptResourceModel(resource: string): {\n    username: string;\n    password: string;\n  } {\n    let username = '';\n    if (resource) {\n      const parts = resource.split(':');\n      parts.pop();\n      username = parts.join(':');\n      if (!this.originalUsername) {\n        this.originalUsername = username;\n        this.originalResource = resource;\n      }\n    }\n\n    return {\n      username,\n      password: '',\n    };\n  }\n\n  override adaptFormModel({\n    username,\n    password,\n  }: {\n    username: string;\n    password: string;\n  }): string {\n    if (!username || !password || !this.form.get('password').dirty) {\n      return this.originalResource;\n    }\n\n    return [username, hashSync(password)].join(':');\n  }\n\n  getLabel(field: OperandField, type: 'username' | 'password') {\n    const capabilities = field.capabilities;\n    const enCapability = `urn:alm:descriptor:${type}:label:en:`;\n    const zhCapability = `urn:alm:descriptor:${type}:label:zh:`;\n    const en = capabilities\n      ?.find(c => c.startsWith(enCapability))\n      ?.split(enCapability)[1];\n    const zh = capabilities\n      ?.find(c => c.startsWith(zhCapability))\n      ?.split(zhCapability)[1];\n    return zh ? { en, zh } : type;\n  }\n}\n"]}

package/esm2022/lib/field-widgets/htpasswd/index.mjs

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

package/esm2022/lib/field-widgets/htpasswd/module.mjs

@@ -0,0 +1,54 @@
+import { FormModule, InputModule } from '@alauda/ui';
+import { ErrorsMapperModule, TranslateModule, CoreModule, StrongPasswordValidatorModule, } from '@alauda-fe/common';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { FieldControlsModule } from '../../field-controls';
+import { HtpasswdComponent } from './component';
+import { HtpasswdFormComponent } from './form';
+import * as i0 from "@angular/core";
+const COMPONENTS = [HtpasswdComponent, HtpasswdFormComponent];
+export class HtpasswdModule {
+    static { this.ɵfac = function HtpasswdModule_Factory(t) { return new (t || HtpasswdModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: HtpasswdModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            FormModule,
+            InputModule,
+            ErrorsMapperModule,
+            StrongPasswordValidatorModule,
+            TranslateModule,
+            CoreModule,
+            FieldControlsModule] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(HtpasswdModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ReactiveFormsModule,
+                    FormModule,
+                    InputModule,
+                    ErrorsMapperModule,
+                    StrongPasswordValidatorModule,
+                    TranslateModule,
+                    CoreModule,
+                    FieldControlsModule,
+                ],
+                declarations: COMPONENTS,
+                exports: COMPONENTS,
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(HtpasswdModule, { declarations: [HtpasswdComponent, HtpasswdFormComponent], imports: [CommonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        FormModule,
+        InputModule,
+        ErrorsMapperModule,
+        StrongPasswordValidatorModule,
+        TranslateModule,
+        CoreModule,
+        FieldControlsModule], exports: [HtpasswdComponent, HtpasswdFormComponent] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/field-widgets/index.mjs

@@ -0,0 +1,2 @@
+export * from './htpasswd';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyZC1mb3JtL3NyYy9saWIvZmllbGQtd2lkZ2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaHRwYXNzd2QnO1xuIl19

package/esm2022/lib/remote-widgets/constants.mjs

@@ -0,0 +1,4 @@
+export const DEFAULT_REMOTE_MFE_MANIFEST = {
+    remotis: 'http://localhost:4211/',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jcmQtZm9ybS9zcmMvbGliL3JlbW90ZS13aWRnZXRzL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxNQUFNLENBQUMsTUFBTSwyQkFBMkIsR0FBRztJQUN6QyxPQUFPLEVBQUUsd0JBQXdCO0NBQ2xDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY29uc3QgREVGQVVMVF9SRU1PVEVfTUZFX01BTklGRVNUID0ge1xuICByZW1vdGlzOiAnaHR0cDovL2xvY2FsaG9zdDo0MjExLycsXG59O1xuIl19

package/esm2022/lib/remote-widgets/index.mjs

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './remote-widget.service';
+export * from './token';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyZC1mb3JtL3NyYy9saWIvcmVtb3RlLXdpZGdldHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vcmVtb3RlLXdpZGdldC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vdG9rZW4nO1xuIl19

package/esm2022/lib/remote-widgets/remote-widget.service.mjs

@@ -0,0 +1,42 @@
+import { K8sApiService, skipError, } from '@alauda-fe/common';
+import { Inject, Injectable, isDevMode } from '@angular/core';
+import { loadRemoteModule, setRemoteDefinitions } from '@nx/angular/mf';
+import { tap, map, of, switchMap, shareReplay, Subject, takeUntil } from 'rxjs';
+import { REMOTE_MFE_MANIFEST } from './token';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda-fe/common";
+export class RemoteWidgetsService {
+    constructor(k8sApi, manifest) {
+        this.k8sApi = k8sApi;
+        this.manifest = manifest;
+        this.destroy$$ = new Subject();
+        this.remoteModule$ = (isDevMode()
+            ? of(this.manifest)
+            : this.k8sApi
+                .getGlobalResource({
+                definition: { type: 'configmaps' },
+                name: 'af-remote-entry-definition',
+                namespaced: true,
+            })
+                .pipe(map(({ data }) => data), skipError())).pipe(tap(setRemoteDefinitions), switchMap(() => loadRemoteModule('remotis', './CrdFormRemoteWidgets')), map((remoteModule) => ({
+            module: remoteModule[remoteModule.REMOTE_MODULE],
+            components: remoteModule.REMOTE_WIDGETS,
+        })), skipError(), takeUntil(this.destroy$$), shareReplay(1));
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function RemoteWidgetsService_Factory(t) { return new (t || RemoteWidgetsService)(i0.ɵɵinject(i1.K8sApiService), i0.ɵɵinject(REMOTE_MFE_MANIFEST)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: RemoteWidgetsService, factory: RemoteWidgetsService.ɵfac, providedIn: 'root' }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RemoteWidgetsService, [{
+        type: Injectable,
+        args: [{
+                providedIn: 'root',
+            }]
+    }], () => [{ type: i1.K8sApiService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [REMOTE_MFE_MANIFEST]
+            }] }], null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/remote-widgets/token.mjs

@@ -0,0 +1,7 @@
+import { InjectionToken } from '@angular/core';
+import { DEFAULT_REMOTE_MFE_MANIFEST } from './constants';
+export const REMOTE_MFE_MANIFEST = new InjectionToken('mock mfe config', {
+    providedIn: 'root',
+    factory: () => DEFAULT_REMOTE_MFE_MANIFEST,
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyZC1mb3JtL3NyYy9saWIvcmVtb3RlLXdpZGdldHMvdG9rZW4udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUUvQyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFMUQsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsSUFBSSxjQUFjLENBQ25ELGlCQUFpQixFQUNqQjtJQUNFLFVBQVUsRUFBRSxNQUFNO0lBQ2xCLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQywyQkFBMkI7Q0FDM0MsQ0FDRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU3RyaW5nTWFwIH0gZnJvbSAnQGFsYXVkYS1mZS9jb21tb24nO1xuaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgREVGQVVMVF9SRU1PVEVfTUZFX01BTklGRVNUIH0gZnJvbSAnLi9jb25zdGFudHMnO1xuXG5leHBvcnQgY29uc3QgUkVNT1RFX01GRV9NQU5JRkVTVCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxTdHJpbmdNYXA+KFxuICAnbW9jayBtZmUgY29uZmlnJyxcbiAge1xuICAgIHByb3ZpZGVkSW46ICdyb290JyxcbiAgICBmYWN0b3J5OiAoKSA9PiBERUZBVUxUX1JFTU9URV9NRkVfTUFOSUZFU1QsXG4gIH0sXG4pO1xuIl19