@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/core/shared/dynamic-form-inputs/code-editor-form-input/base-code-editor-form-input.component.js

@@ -0,0 +1,59 @@
+import { ChangeDetectorRef, Directive, ViewChild } from '@angular/core';
+import { CodeJar } from 'codejar';
+export class BaseCodeEditorFormInputComponent {
+    constructor(changeDetector) {
+        this.changeDetector = changeDetector;
+        this.isValid = true;
+    }
+    get height() {
+        var _a;
+        return ((_a = this.config.ui) === null || _a === void 0 ? void 0 : _a.height) || this.config.height;
+    }
+    configure(config) {
+        this.formControl.addValidators(config.validator);
+        this.highlight = config.highlight;
+        this.getErrorMessage = config.getErrorMessage;
+    }
+    ngAfterViewInit() {
+        let lastVal = '';
+        const highlight = (editor) => {
+            var _a;
+            const code = (_a = editor.textContent) !== null && _a !== void 0 ? _a : '';
+            if (code === lastVal) {
+                return;
+            }
+            lastVal = code;
+            this.errorMessage = this.getErrorMessage(code);
+            this.changeDetector.markForCheck();
+            editor.innerHTML = this.highlight(code, this.getErrorPos(this.errorMessage));
+        };
+        this.jar = CodeJar(this.editorElementRef.nativeElement, highlight);
+        this.jar.onUpdate(value => {
+            this.formControl.setValue(value);
+            this.formControl.markAsDirty();
+            this.isValid = this.formControl.valid;
+        });
+        this.jar.updateCode(this.formControl.value);
+        if (this.readonly) {
+            this.editorElementRef.nativeElement.contentEditable = 'false';
+        }
+    }
+    getErrorPos(errorMessage) {
+        if (!errorMessage) {
+            return;
+        }
+        const matches = errorMessage.match(/at position (\d+)/);
+        const pos = matches === null || matches === void 0 ? void 0 : matches[1];
+        return pos != null ? +pos : undefined;
+    }
+}
+BaseCodeEditorFormInputComponent.decorators = [
+    { type: Directive }
+];
+BaseCodeEditorFormInputComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+BaseCodeEditorFormInputComponent.propDecorators = {
+    editorElementRef: [{ type: ViewChild, args: ['editor',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/package/esm2015/core/shared/dynamic-form-inputs/code-editor-form-input/html-editor-form-input.component.js

@@ -0,0 +1,66 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component } from '@angular/core';
+import { BaseCodeEditorFormInputComponent } from './base-code-editor-form-input.component';
+function htmlValidator() {
+    return (control) => {
+        return null;
+    };
+}
+const HTML_TAG_RE = /<\/?[^>]+>?/g;
+/**
+ * @description
+ * A JSON editor input with syntax highlighting and error detection. Works well
+ * with `text` type fields.
+ *
+ * @docsCategory custom-input-components
+ * @docsPage default-inputs
+ */
+export class HtmlEditorFormInputComponent extends BaseCodeEditorFormInputComponent {
+    constructor(changeDetector) {
+        super(changeDetector);
+        this.changeDetector = changeDetector;
+    }
+    ngOnInit() {
+        this.configure({
+            validator: htmlValidator,
+            highlight: (html, errorPos) => {
+                let hasMarkedError = false;
+                return html.replace(HTML_TAG_RE, (match, ...args) => {
+                    let errorClass = '';
+                    if (errorPos && !hasMarkedError) {
+                        const length = args[0].length;
+                        const offset = args[4];
+                        if (errorPos <= length + offset) {
+                            errorClass = 'je-error';
+                            hasMarkedError = true;
+                        }
+                    }
+                    return ('<span class="he-tag' +
+                        ' ' +
+                        errorClass +
+                        '">' +
+                        this.encodeHtmlChars(match).replace(/([a-zA-Z0-9-]+=)(["'][^'"]*["'])/g, (_match, ..._args) => `${_args[0]}<span class="he-attr">${_args[1]}</span>`) +
+                        '</span>');
+                });
+            },
+            getErrorMessage: (json) => {
+                return;
+            },
+        });
+    }
+    encodeHtmlChars(html) {
+        return html.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+}
+HtmlEditorFormInputComponent.id = 'html-editor-form-input';
+HtmlEditorFormInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-html-editor-form-input',
+                template: "<div #editor class=\"code-editor html-editor\" [class.invalid]=\"!isValid\" [style.height]=\"height || '300px'\"></div>\r\n<div class=\"error-message\">\r\n    <span *ngIf=\"errorMessage\">{{ errorMessage }}</span>\r\n</div>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [".code-editor{min-height:6rem;background-color:var(--color-json-editor-background-color);color:var(--color-json-editor-text);border:1px solid var(--color-component-border-200);border-radius:3px;padding:6px;-moz-tab-size:4;tab-size:4;font-family:\"Source Code Pro\",\"Lucida Console\",Monaco,monospace;font-size:14px;font-weight:400;height:340px;letter-spacing:normal;line-height:20px;resize:both;text-align:initial;min-width:200px}.code-editor:focus{border-color:var(--color-primary-500)}.code-editor.invalid{border-color:var(--clr-forms-invalid-color)}.error-message{min-height:1rem;color:var(--color-json-editor-error)}.code-editor ::ng-deep .he-tag{color:var(--color-json-editor-key)}.code-editor ::ng-deep .he-attr{color:var(--color-json-editor-number)}.code-editor ::ng-deep .he-error{-webkit-text-decoration-line:underline;text-decoration-line:underline;-webkit-text-decoration-style:wavy;text-decoration-style:wavy;-webkit-text-decoration-color:var(--color-json-editor-error);text-decoration-color:var(--color-json-editor-error)}\n"]
+            },] }
+];
+HtmlEditorFormInputComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbC1lZGl0b3ItZm9ybS1pbnB1dC5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9keW5hbWljLWZvcm0taW5wdXRzL2NvZGUtZWRpdG9yLWZvcm0taW5wdXQvaHRtbC1lZGl0b3ItZm9ybS1pbnB1dC5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFpQix1QkFBdUIsRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQVUsTUFBTSxlQUFlLENBQUM7QUFNN0csT0FBTyxFQUFFLGdDQUFnQyxFQUFFLE1BQU0seUNBQXlDLENBQUM7QUFFM0YsU0FBUyxhQUFhO0lBQ2xCLE9BQU8sQ0FBQyxPQUF3QixFQUEyQixFQUFFO1FBQ3pELE9BQU8sSUFBSSxDQUFDO0lBQ2hCLENBQUMsQ0FBQztBQUNOLENBQUM7QUFFRCxNQUFNLFdBQVcsR0FBRyxjQUFjLENBQUM7QUFFbkM7Ozs7Ozs7R0FPRztBQU9ILE1BQU0sT0FBTyw0QkFDVCxTQUFRLGdDQUFnQztJQUt4QyxZQUFzQixjQUFpQztRQUNuRCxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7UUFESixtQkFBYyxHQUFkLGNBQWMsQ0FBbUI7SUFFdkQsQ0FBQztJQUVELFFBQVE7UUFDSixJQUFJLENBQUMsU0FBUyxDQUFDO1lBQ1gsU0FBUyxFQUFFLGFBQWE7WUFDeEIsU0FBUyxFQUFFLENBQUMsSUFBWSxFQUFFLFFBQTRCLEVBQUUsRUFBRTtnQkFDdEQsSUFBSSxjQUFjLEdBQUcsS0FBSyxDQUFDO2dCQUMzQixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsV0FBVyxFQUFFLENBQUMsS0FBSyxFQUFFLEdBQUcsSUFBSSxFQUFFLEVBQUU7b0JBQ2hELElBQUksVUFBVSxHQUFHLEVBQUUsQ0FBQztvQkFDcEIsSUFBSSxRQUFRLElBQUksQ0FBQyxjQUFjLEVBQUU7d0JBQzdCLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7d0JBQzlCLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxDQUFDLENBQUMsQ0FBQzt3QkFDdkIsSUFBSSxRQUFRLElBQUksTUFBTSxHQUFHLE1BQU0sRUFBRTs0QkFDN0IsVUFBVSxHQUFHLFVBQVUsQ0FBQzs0QkFDeEIsY0FBYyxHQUFHLElBQUksQ0FBQzt5QkFDekI7cUJBQ0o7b0JBQ0QsT0FBTyxDQUNILHFCQUFxQjt3QkFDckIsR0FBRzt3QkFDSCxVQUFVO3dCQUNWLElBQUk7d0JBQ0osSUFBSSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxPQUFPLENBQy9CLG1DQUFtQyxFQUNuQyxDQUFDLE1BQU0sRUFBRSxHQUFHLEtBQUssRUFBRSxFQUFFLENBQUMsR0FBRyxLQUFLLENBQUMsQ0FBQyxDQUFDLHlCQUF5QixLQUFLLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FDOUU7d0JBQ0QsU0FBUyxDQUNaLENBQUM7Z0JBQ04sQ0FBQyxDQUFDLENBQUM7WUFDUCxDQUFDO1lBQ0QsZUFBZSxFQUFFLENBQUMsSUFBWSxFQUFzQixFQUFFO2dCQUNsRCxPQUFPO1lBQ1gsQ0FBQztTQUNKLENBQUMsQ0FBQztJQUNQLENBQUM7SUFFTyxlQUFlLENBQUMsSUFBWTtRQUNoQyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsTUFBTSxDQUFDLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNuRixDQUFDOztBQTFDZSwrQkFBRSxHQUEyQix3QkFBd0IsQ0FBQzs7WUFWekUsU0FBUyxTQUFDO2dCQUNQLFFBQVEsRUFBRSw0QkFBNEI7Z0JBQ3RDLGdQQUFzRDtnQkFFdEQsZUFBZSxFQUFFLHVCQUF1QixDQUFDLE1BQU07O2FBQ2xEOzs7WUE3QmdELGlCQUFpQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFmdGVyVmlld0luaXQsIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LCBDaGFuZ2VEZXRlY3RvclJlZiwgQ29tcG9uZW50LCBPbkluaXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0aW9uRXJyb3JzLCBWYWxpZGF0b3JGbiB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJztcclxuaW1wb3J0IHsgRGVmYXVsdEZvcm1Db21wb25lbnRJZCB9IGZyb20gJ0B2ZW5kdXJlL2NvbW1vbi9saWIvc2hhcmVkLXR5cGVzJztcclxuXHJcbmltcG9ydCB7IEZvcm1JbnB1dENvbXBvbmVudCB9IGZyb20gJy4uLy4uLy4uL2NvbW1vbi9jb21wb25lbnQtcmVnaXN0cnktdHlwZXMnO1xyXG5cclxuaW1wb3J0IHsgQmFzZUNvZGVFZGl0b3JGb3JtSW5wdXRDb21wb25lbnQgfSBmcm9tICcuL2Jhc2UtY29kZS1lZGl0b3ItZm9ybS1pbnB1dC5jb21wb25lbnQnO1xyXG5cclxuZnVuY3Rpb24gaHRtbFZhbGlkYXRvcigpOiBWYWxpZGF0b3JGbiB7XHJcbiAgICByZXR1cm4gKGNvbnRyb2w6IEFic3RyYWN0Q29udHJvbCk6IFZhbGlkYXRpb25FcnJvcnMgfCBudWxsID0+IHtcclxuICAgICAgICByZXR1cm4gbnVsbDtcclxuICAgIH07XHJcbn1cclxuXHJcbmNvbnN0IEhUTUxfVEFHX1JFID0gLzxcXC8/W14+XSs+Py9nO1xyXG5cclxuLyoqXHJcbiAqIEBkZXNjcmlwdGlvblxyXG4gKiBBIEpTT04gZWRpdG9yIGlucHV0IHdpdGggc3ludGF4IGhpZ2hsaWdodGluZyBhbmQgZXJyb3IgZGV0ZWN0aW9uLiBXb3JrcyB3ZWxsXHJcbiAqIHdpdGggYHRleHRgIHR5cGUgZmllbGRzLlxyXG4gKlxyXG4gKiBAZG9jc0NhdGVnb3J5IGN1c3RvbS1pbnB1dC1jb21wb25lbnRzXHJcbiAqIEBkb2NzUGFnZSBkZWZhdWx0LWlucHV0c1xyXG4gKi9cclxuQENvbXBvbmVudCh7XHJcbiAgICBzZWxlY3RvcjogJ3Zkci1odG1sLWVkaXRvci1mb3JtLWlucHV0JyxcclxuICAgIHRlbXBsYXRlVXJsOiAnLi9odG1sLWVkaXRvci1mb3JtLWlucHV0LmNvbXBvbmVudC5odG1sJyxcclxuICAgIHN0eWxlVXJsczogWycuL2h0bWwtZWRpdG9yLWZvcm0taW5wdXQuY29tcG9uZW50LnNjc3MnXSxcclxuICAgIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxyXG59KVxyXG5leHBvcnQgY2xhc3MgSHRtbEVkaXRvckZvcm1JbnB1dENvbXBvbmVudFxyXG4gICAgZXh0ZW5kcyBCYXNlQ29kZUVkaXRvckZvcm1JbnB1dENvbXBvbmVudFxyXG4gICAgaW1wbGVtZW50cyBGb3JtSW5wdXRDb21wb25lbnQsIEFmdGVyVmlld0luaXQsIE9uSW5pdFxyXG57XHJcbiAgICBzdGF0aWMgcmVhZG9ubHkgaWQ6IERlZmF1bHRGb3JtQ29tcG9uZW50SWQgPSAnaHRtbC1lZGl0b3ItZm9ybS1pbnB1dCc7XHJcblxyXG4gICAgY29uc3RydWN0b3IocHJvdGVjdGVkIGNoYW5nZURldGVjdG9yOiBDaGFuZ2VEZXRlY3RvclJlZikge1xyXG4gICAgICAgIHN1cGVyKGNoYW5nZURldGVjdG9yKTtcclxuICAgIH1cclxuXHJcbiAgICBuZ09uSW5pdCgpIHtcclxuICAgICAgICB0aGlzLmNvbmZpZ3VyZSh7XHJcbiAgICAgICAgICAgIHZhbGlkYXRvcjogaHRtbFZhbGlkYXRvcixcclxuICAgICAgICAgICAgaGlnaGxpZ2h0OiAoaHRtbDogc3RyaW5nLCBlcnJvclBvczogbnVtYmVyIHwgdW5kZWZpbmVkKSA9PiB7XHJcbiAgICAgICAgICAgICAgICBsZXQgaGFzTWFya2VkRXJyb3IgPSBmYWxzZTtcclxuICAgICAgICAgICAgICAgIHJldHVybiBodG1sLnJlcGxhY2UoSFRNTF9UQUdfUkUsIChtYXRjaCwgLi4uYXJncykgPT4ge1xyXG4gICAgICAgICAgICAgICAgICAgIGxldCBlcnJvckNsYXNzID0gJyc7XHJcbiAgICAgICAgICAgICAgICAgICAgaWYgKGVycm9yUG9zICYmICFoYXNNYXJrZWRFcnJvcikge1xyXG4gICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBsZW5ndGggPSBhcmdzWzBdLmxlbmd0aDtcclxuICAgICAgICAgICAgICAgICAgICAgICAgY29uc3Qgb2Zmc2V0ID0gYXJnc1s0XTtcclxuICAgICAgICAgICAgICAgICAgICAgICAgaWYgKGVycm9yUG9zIDw9IGxlbmd0aCArIG9mZnNldCkge1xyXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgZXJyb3JDbGFzcyA9ICdqZS1lcnJvcic7XHJcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICBoYXNNYXJrZWRFcnJvciA9IHRydWU7XHJcbiAgICAgICAgICAgICAgICAgICAgICAgIH1cclxuICAgICAgICAgICAgICAgICAgICB9XHJcbiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIChcclxuICAgICAgICAgICAgICAgICAgICAgICAgJzxzcGFuIGNsYXNzPVwiaGUtdGFnJyArXHJcbiAgICAgICAgICAgICAgICAgICAgICAgICcgJyArXHJcbiAgICAgICAgICAgICAgICAgICAgICAgIGVycm9yQ2xhc3MgK1xyXG4gICAgICAgICAgICAgICAgICAgICAgICAnXCI+JyArXHJcbiAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMuZW5jb2RlSHRtbENoYXJzKG1hdGNoKS5yZXBsYWNlKFxyXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgLyhbYS16QS1aMC05LV0rPSkoW1wiJ11bXidcIl0qW1wiJ10pL2csXHJcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAoX21hdGNoLCAuLi5fYXJncykgPT4gYCR7X2FyZ3NbMF19PHNwYW4gY2xhc3M9XCJoZS1hdHRyXCI+JHtfYXJnc1sxXX08L3NwYW4+YCxcclxuICAgICAgICAgICAgICAgICAgICAgICAgKSArXHJcbiAgICAgICAgICAgICAgICAgICAgICAgICc8L3NwYW4+J1xyXG4gICAgICAgICAgICAgICAgICAgICk7XHJcbiAgICAgICAgICAgICAgICB9KTtcclxuICAgICAgICAgICAgfSxcclxuICAgICAgICAgICAgZ2V0RXJyb3JNZXNzYWdlOiAoanNvbjogc3RyaW5nKTogc3RyaW5nIHwgdW5kZWZpbmVkID0+IHtcclxuICAgICAgICAgICAgICAgIHJldHVybjtcclxuICAgICAgICAgICAgfSxcclxuICAgICAgICB9KTtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIGVuY29kZUh0bWxDaGFycyhodG1sOiBzdHJpbmcpOiBzdHJpbmcge1xyXG4gICAgICAgIHJldHVybiBodG1sLnJlcGxhY2UoLyYvZywgJyZhbXA7JykucmVwbGFjZSgvPC9nLCAnJmx0OycpLnJlcGxhY2UoLz4vZywgJyZndDsnKTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/package/esm2015/core/shared/dynamic-form-inputs/code-editor-form-input/json-editor-form-input.component.js

@@ -0,0 +1,88 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component } from '@angular/core';
+import { BaseCodeEditorFormInputComponent } from './base-code-editor-form-input.component';
+export function jsonValidator() {
+    return (control) => {
+        const error = { jsonInvalid: true };
+        try {
+            JSON.parse(control.value);
+        }
+        catch (e) {
+            control.setErrors(error);
+            return error;
+        }
+        control.setErrors(null);
+        return null;
+    };
+}
+/**
+ * @description
+ * A JSON editor input with syntax highlighting and error detection. Works well
+ * with `text` type fields.
+ *
+ * @docsCategory custom-input-components
+ * @docsPage default-inputs
+ */
+export class JsonEditorFormInputComponent extends BaseCodeEditorFormInputComponent {
+    constructor(changeDetector) {
+        super(changeDetector);
+        this.changeDetector = changeDetector;
+    }
+    ngOnInit() {
+        this.configure({
+            validator: jsonValidator,
+            highlight: (json, errorPos) => {
+                json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+                let hasMarkedError = false;
+                return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, (match, ...args) => {
+                    let cls = 'number';
+                    if (/^"/.test(match)) {
+                        if (/:$/.test(match)) {
+                            cls = 'key';
+                        }
+                        else {
+                            cls = 'string';
+                        }
+                    }
+                    else if (/true|false/.test(match)) {
+                        cls = 'boolean';
+                    }
+                    else if (/null/.test(match)) {
+                        cls = 'null';
+                    }
+                    let errorClass = '';
+                    if (errorPos && !hasMarkedError) {
+                        const length = args[0].length;
+                        const offset = args[4];
+                        if (errorPos <= length + offset) {
+                            errorClass = 'je-error';
+                            hasMarkedError = true;
+                        }
+                    }
+                    return '<span class="je-' + cls + ' ' + errorClass + '">' + match + '</span>';
+                });
+            },
+            getErrorMessage: (json) => {
+                try {
+                    JSON.parse(json);
+                }
+                catch (e) {
+                    return e.message;
+                }
+                return;
+            },
+        });
+    }
+}
+JsonEditorFormInputComponent.id = 'json-editor-form-input';
+JsonEditorFormInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-json-editor-form-input',
+                template: "<div #editor class=\"code-editor json-editor\" [class.invalid]=\"!isValid\" [style.height]=\"height || '300px'\"></div>\r\n<div class=\"error-message\">\r\n    <span *ngIf=\"errorMessage\">{{ errorMessage }}</span>\r\n</div>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                styles: [".code-editor{min-height:6rem;background-color:var(--color-json-editor-background-color);color:var(--color-json-editor-text);border:1px solid var(--color-component-border-200);border-radius:3px;padding:6px;-moz-tab-size:4;tab-size:4;font-family:\"Source Code Pro\",\"Lucida Console\",Monaco,monospace;font-size:14px;font-weight:400;height:340px;letter-spacing:normal;line-height:20px;resize:both;text-align:initial;min-width:200px}.code-editor:focus{border-color:var(--color-primary-500)}.code-editor.invalid{border-color:var(--clr-forms-invalid-color)}.error-message{min-height:1rem;color:var(--color-json-editor-error)}.code-editor ::ng-deep .je-string{color:var(--color-json-editor-string)}.code-editor ::ng-deep .je-number{color:var(--color-json-editor-number)}.code-editor ::ng-deep .je-boolean{color:var(--color-json-editor-boolean)}.code-editor ::ng-deep .je-null{color:var(--color-json-editor-null)}.code-editor ::ng-deep .je-key{color:var(--color-json-editor-key)}.code-editor ::ng-deep .je-error{-webkit-text-decoration-line:underline;text-decoration-line:underline;-webkit-text-decoration-style:wavy;text-decoration-style:wavy;-webkit-text-decoration-color:var(--color-json-editor-error);text-decoration-color:var(--color-json-editor-error)}\n"]
+            },] }
+];
+JsonEditorFormInputComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-editor-form-input.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/dynamic-form-inputs/code-editor-form-input/json-editor-form-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterViewInit, ChangeDetectionStrategy, ChangeDetectorRef, Component, OnInit } from '@angular/core';\r\nimport { AbstractControl, ValidationErrors, ValidatorFn } from '@angular/forms';\r\nimport { DefaultFormComponentId } from '@vendure/common/lib/shared-types';\r\n\r\nimport { FormInputComponent } from '../../../common/component-registry-types';\r\n\r\nimport { BaseCodeEditorFormInputComponent } from './base-code-editor-form-input.component';\r\n\r\nexport function jsonValidator(): ValidatorFn {\r\n    return (control: AbstractControl): ValidationErrors | null => {\r\n        const error: ValidationErrors = { jsonInvalid: true };\r\n\r\n        try {\r\n            JSON.parse(control.value);\r\n        } catch (e) {\r\n            control.setErrors(error);\r\n            return error;\r\n        }\r\n\r\n        control.setErrors(null);\r\n        return null;\r\n    };\r\n}\r\n\r\n/**\r\n * @description\r\n * A JSON editor input with syntax highlighting and error detection. Works well\r\n * with `text` type fields.\r\n *\r\n * @docsCategory custom-input-components\r\n * @docsPage default-inputs\r\n */\r\n@Component({\r\n    selector: 'vdr-json-editor-form-input',\r\n    templateUrl: './json-editor-form-input.component.html',\r\n    styleUrls: ['./json-editor-form-input.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n})\r\nexport class JsonEditorFormInputComponent\r\n    extends BaseCodeEditorFormInputComponent\r\n    implements FormInputComponent, AfterViewInit, OnInit\r\n{\r\n    static readonly id: DefaultFormComponentId = 'json-editor-form-input';\r\n\r\n    constructor(protected changeDetector: ChangeDetectorRef) {\r\n        super(changeDetector);\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.configure({\r\n            validator: jsonValidator,\r\n            highlight: (json: string, errorPos: number | undefined) => {\r\n                json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');\r\n                let hasMarkedError = false;\r\n                return json.replace(\r\n                    /(\"(\\\\u[a-zA-Z0-9]{4}|\\\\[^u]|[^\\\\\"])*\"(\\s*:)?|\\b(true|false|null)\\b|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?)/g,\r\n                    (match, ...args) => {\r\n                        let cls = 'number';\r\n                        if (/^\"/.test(match)) {\r\n                            if (/:$/.test(match)) {\r\n                                cls = 'key';\r\n                            } else {\r\n                                cls = 'string';\r\n                            }\r\n                        } else if (/true|false/.test(match)) {\r\n                            cls = 'boolean';\r\n                        } else if (/null/.test(match)) {\r\n                            cls = 'null';\r\n                        }\r\n                        let errorClass = '';\r\n                        if (errorPos && !hasMarkedError) {\r\n                            const length = args[0].length;\r\n                            const offset = args[4];\r\n                            if (errorPos <= length + offset) {\r\n                                errorClass = 'je-error';\r\n                                hasMarkedError = true;\r\n                            }\r\n                        }\r\n                        return '<span class=\"je-' + cls + ' ' + errorClass + '\">' + match + '</span>';\r\n                    },\r\n                );\r\n            },\r\n            getErrorMessage: (json: string): string | undefined => {\r\n                try {\r\n                    JSON.parse(json);\r\n                } catch (e) {\r\n                    return e.message;\r\n                }\r\n                return;\r\n            },\r\n        });\r\n    }\r\n}\r\n"]}

package/package/esm2015/core/shared/dynamic-form-inputs/dynamic-form-input/dynamic-form-input.component.js

@@ -0,0 +1,266 @@
+import { moveItemInArray } from '@angular/cdk/drag-drop';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactoryResolver, Injector, Input, ViewChild, ViewChildren, ViewContainerRef, } from '@angular/core';
+import { FormArray, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { assertNever } from '@vendure/common/lib/shared-utils';
+import { simpleDeepClone } from '@vendure/common/lib/simple-deep-clone';
+import { Subject } from 'rxjs';
+import { switchMap, take, takeUntil } from 'rxjs/operators';
+import { getConfigArgValue } from '../../../common/utilities/configurable-operation-utils';
+import { ComponentRegistryService } from '../../../providers/component-registry/component-registry.service';
+/**
+ * A host component which delegates to an instance or list of FormInputComponent components.
+ */
+export class DynamicFormInputComponent {
+    constructor(componentRegistryService, componentFactoryResolver, changeDetectorRef, injector) {
+        this.componentRegistryService = componentRegistryService;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.changeDetectorRef = changeDetectorRef;
+        this.injector = injector;
+        this.renderAsList = false;
+        this.listItems = [];
+        this.listId = 1;
+        this.listFormArray = new FormArray([]);
+        this.renderList$ = new Subject();
+        this.destroy$ = new Subject();
+    }
+    ngOnInit() {
+        const componentId = this.getInputComponentConfig(this.def).component;
+        const componentType = this.componentRegistryService.getInputComponent(componentId);
+        if (componentType) {
+            this.componentType = componentType;
+        }
+        else {
+            // tslint:disable-next-line:no-console
+            console.error(`No form input component registered with the id "${componentId}". Using the default input instead.`);
+            const defaultComponentType = this.componentRegistryService.getInputComponent(this.getInputComponentConfig(Object.assign(Object.assign({}, this.def), { ui: undefined })).component);
+            if (defaultComponentType) {
+                this.componentType = defaultComponentType;
+            }
+        }
+    }
+    ngAfterViewInit() {
+        var _a;
+        if (this.componentType) {
+            const factory = this.componentFactoryResolver.resolveComponentFactory(this.componentType);
+            // create a temp instance to check the value of `isListInput`
+            const cmpRef = factory.create(this.injector);
+            const isListInputComponent = (_a = cmpRef.instance.isListInput) !== null && _a !== void 0 ? _a : false;
+            cmpRef.destroy();
+            if (this.def.list === false && isListInputComponent) {
+                throw new Error(`The ${this.componentType.name} component is a list input, but the definition for ${this.def.name} does not expect a list`);
+            }
+            this.renderAsList = this.def.list && !isListInputComponent;
+            if (!this.renderAsList) {
+                this.singleComponentRef = this.renderInputComponent(factory, this.singleViewContainer, this.control);
+            }
+            else {
+                let formArraySub;
+                const renderListInputs = (viewContainerRefs) => {
+                    if (viewContainerRefs.length) {
+                        if (formArraySub) {
+                            formArraySub.unsubscribe();
+                        }
+                        this.listFormArray = new FormArray([]);
+                        this.listItems.forEach(i => { var _a; return (_a = i.componentRef) === null || _a === void 0 ? void 0 : _a.destroy(); });
+                        viewContainerRefs.forEach((ref, i) => {
+                            var _a;
+                            const listItem = (_a = this.listItems) === null || _a === void 0 ? void 0 : _a[i];
+                            if (listItem) {
+                                this.listFormArray.push(listItem.control);
+                                listItem.componentRef = this.renderInputComponent(factory, ref, listItem.control);
+                            }
+                        });
+                        formArraySub = this.listFormArray.valueChanges
+                            .pipe(takeUntil(this.destroy$))
+                            .subscribe(val => {
+                            this.control.markAsTouched();
+                            this.control.markAsDirty();
+                            this.onChange(val);
+                            this.control.patchValue(val, { emitEvent: false });
+                        });
+                        setTimeout(() => this.changeDetectorRef.markForCheck());
+                    }
+                };
+                // initial render
+                this.listItemContainers.changes
+                    .pipe(take(1))
+                    .subscribe(val => renderListInputs(this.listItemContainers));
+                // render on changes to the list
+                this.renderList$
+                    .pipe(switchMap(() => this.listItemContainers.changes.pipe(take(1))), takeUntil(this.destroy$))
+                    .subscribe(() => {
+                    renderListInputs(this.listItemContainers);
+                });
+            }
+        }
+        setTimeout(() => this.changeDetectorRef.markForCheck());
+    }
+    ngOnChanges(changes) {
+        if (this.listItems) {
+            for (const item of this.listItems) {
+                if (item.componentRef) {
+                    this.updateBindings(changes, item.componentRef);
+                }
+            }
+        }
+        if (this.singleComponentRef) {
+            this.updateBindings(changes, this.singleComponentRef);
+        }
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    updateBindings(changes, componentRef) {
+        if ('def' in changes) {
+            componentRef.instance.config = simpleDeepClone(this.def);
+        }
+        if ('readonly' in changes) {
+            componentRef.instance.readonly = this.readonly;
+        }
+        componentRef.injector.get(ChangeDetectorRef).markForCheck();
+    }
+    trackById(index, item) {
+        return item.id;
+    }
+    addListItem() {
+        var _a;
+        if (!this.listItems) {
+            this.listItems = [];
+        }
+        this.listItems.push({
+            id: this.listId++,
+            control: new FormControl((_a = this.def.defaultValue) !== null && _a !== void 0 ? _a : null),
+        });
+        this.renderList$.next();
+    }
+    moveListItem(event) {
+        if (this.listItems) {
+            moveItemInArray(this.listItems, event.previousIndex, event.currentIndex);
+            this.listFormArray.removeAt(event.previousIndex);
+            this.listFormArray.insert(event.currentIndex, event.item.data.control);
+            this.renderList$.next();
+        }
+    }
+    removeListItem(item) {
+        var _a;
+        if (this.listItems) {
+            const index = this.listItems.findIndex(i => i === item);
+            (_a = item.componentRef) === null || _a === void 0 ? void 0 : _a.destroy();
+            this.listFormArray.removeAt(index);
+            this.listItems = this.listItems.filter(i => i !== item);
+            this.renderList$.next();
+        }
+    }
+    renderInputComponent(factory, viewContainerRef, formControl) {
+        const componentRef = viewContainerRef.createComponent(factory);
+        const { instance } = componentRef;
+        instance.config = simpleDeepClone(this.def);
+        instance.formControl = formControl;
+        instance.readonly = this.readonly;
+        componentRef.injector.get(ChangeDetectorRef).markForCheck();
+        return componentRef;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    writeValue(obj) {
+        if (Array.isArray(obj)) {
+            if (obj.length === this.listItems.length) {
+                obj.forEach((value, index) => {
+                    var _a;
+                    const control = (_a = this.listItems[index]) === null || _a === void 0 ? void 0 : _a.control;
+                    control.patchValue(getConfigArgValue(value), { emitEvent: false });
+                });
+            }
+            else {
+                this.listItems = obj.map(value => ({
+                    id: this.listId++,
+                    control: new FormControl(getConfigArgValue(value)),
+                }));
+                this.renderList$.next();
+            }
+        }
+        else {
+            this.listItems = [];
+            this.renderList$.next();
+        }
+        this.changeDetectorRef.markForCheck();
+    }
+    getInputComponentConfig(argDef) {
+        var _a;
+        if (this.hasUiConfig(argDef) && argDef.ui.component) {
+            return argDef.ui;
+        }
+        const type = argDef === null || argDef === void 0 ? void 0 : argDef.type;
+        switch (type) {
+            case 'string':
+            case 'localeString': {
+                const hasOptions = !!(this.isConfigArgDef(argDef) && ((_a = argDef.ui) === null || _a === void 0 ? void 0 : _a.options)) ||
+                    !!argDef.options;
+                if (hasOptions) {
+                    return { component: 'select-form-input' };
+                }
+                else {
+                    return { component: 'text-form-input' };
+                }
+            }
+            case 'text': {
+                return { component: 'textarea-form-input' };
+            }
+            case 'int':
+            case 'float':
+                return { component: 'number-form-input' };
+            case 'boolean':
+                return { component: 'boolean-form-input' };
+            case 'datetime':
+                return { component: 'date-form-input' };
+            case 'ID':
+                return { component: 'text-form-input' };
+            case 'relation':
+                return { component: 'relation-form-input' };
+            default:
+                assertNever(type);
+        }
+    }
+    isConfigArgDef(def) {
+        var _a;
+        return ((_a = def) === null || _a === void 0 ? void 0 : _a.__typename) === 'ConfigArgDefinition';
+    }
+    hasUiConfig(def) {
+        var _a, _b;
+        return typeof def === 'object' && typeof ((_b = (_a = def) === null || _a === void 0 ? void 0 : _a.ui) === null || _b === void 0 ? void 0 : _b.component) === 'string';
+    }
+}
+DynamicFormInputComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-dynamic-form-input',
+                template: "<ng-container *ngIf=\"!renderAsList; else list\">\r\n    <ng-container #single></ng-container>\r\n</ng-container>\r\n<ng-template #list>\r\n    <div class=\"list-container\" cdkDropList (cdkDropListDropped)=\"moveListItem($event)\">\r\n        <div\r\n            class=\"list-item-row\"\r\n            *ngFor=\"let item of listItems; trackBy: trackById\"\r\n            cdkDrag\r\n            [cdkDragData]=\"item\"\r\n        >\r\n            <ng-container #listItem></ng-container>\r\n            <button\r\n                class=\"btn btn-link btn-sm btn-warning\"\r\n                *ngIf=\"!readonly\"\r\n                (click)=\"removeListItem(item)\"\r\n                [title]=\"'common.remove-item-from-list' | translate\"\r\n            >\r\n                <clr-icon shape=\"times\"></clr-icon>\r\n            </button>\r\n            <div class=\"flex-spacer\"></div>\r\n            <div class=\"drag-handle\" cdkDragHandle [class.hidden]=\"readonly\">\r\n                <clr-icon shape=\"drag-handle\" size=\"24\"></clr-icon>\r\n            </div>\r\n        </div>\r\n        <button class=\"btn btn-secondary btn-sm\" (click)=\"addListItem()\" *ngIf=\"!readonly\">\r\n            <clr-icon shape=\"plus\"></clr-icon> {{ 'common.add-item-to-list' | translate }}\r\n        </button>\r\n    </div>\r\n</ng-template>\r\n",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: DynamicFormInputComponent,
+                        multi: true,
+                    },
+                ],
+                styles: [":host{flex:1}.list-container{border:1px solid var(--color-component-border-200);border-radius:3px;padding:12px}.list-item-row{font-size:13px;display:flex;align-items:center;margin:3px 0}.drag-placeholder{transition:transform .25s cubic-bezier(0,0,.2,1)}.cdk-drag-preview{font-size:13px;background-color:var(--color-component-bg-100);opacity:.8;border-radius:4px;box-shadow:0 5px 5px -3px #0003,0 8px 10px 1px #00000024,0 3px 14px 2px #0000001f}.drag-handle.hidden{display:none}.cdk-drag-placeholder{opacity:.1}.cdk-drag-animating{transition:transform .25s cubic-bezier(0,0,.2,1)}.cdk-drop-list-dragging .list-item-row:not(.cdk-drag-placeholder){transition:transform .25s cubic-bezier(0,0,.2,1)}\n"]
+            },] }
+];
+DynamicFormInputComponent.ctorParameters = () => [
+    { type: ComponentRegistryService },
+    { type: ComponentFactoryResolver },
+    { type: ChangeDetectorRef },
+    { type: Injector }
+];
+DynamicFormInputComponent.propDecorators = {
+    def: [{ type: Input }],
+    readonly: [{ type: Input }],
+    control: [{ type: Input }],
+    singleViewContainer: [{ type: ViewChild, args: ['single', { read: ViewContainerRef },] }],
+    listItemContainers: [{ type: ViewChildren, args: ['listItem', { read: ViewContainerRef },] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dynamic-form-input.component.js","sourceRoot":"","sources":["../../../../../../src/lib/core/src/shared/dynamic-form-inputs/dynamic-form-input/dynamic-form-input.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';\r\nimport {\r\n    AfterViewInit,\r\n    ChangeDetectionStrategy,\r\n    ChangeDetectorRef,\r\n    Component,\r\n    ComponentFactory,\r\n    ComponentFactoryResolver,\r\n    ComponentRef,\r\n    Injector,\r\n    Input,\r\n    OnChanges,\r\n    OnDestroy,\r\n    OnInit,\r\n    QueryList,\r\n    SimpleChanges,\r\n    Type,\r\n    ViewChild,\r\n    ViewChildren,\r\n    ViewContainerRef,\r\n} from '@angular/core';\r\nimport { ControlValueAccessor, FormArray, FormControl, NG_VALUE_ACCESSOR } from '@angular/forms';\r\nimport { StringCustomFieldConfig } from '@vendure/common/lib/generated-types';\r\nimport { ConfigArgType, CustomFieldType, DefaultFormComponentId } from '@vendure/common/lib/shared-types';\r\nimport { assertNever } from '@vendure/common/lib/shared-utils';\r\nimport { simpleDeepClone } from '@vendure/common/lib/simple-deep-clone';\r\nimport { Subject, Subscription } from 'rxjs';\r\nimport { switchMap, take, takeUntil } from 'rxjs/operators';\r\n\r\nimport { FormInputComponent } from '../../../common/component-registry-types';\r\nimport { ConfigArgDefinition, CustomFieldConfig } from '../../../common/generated-types';\r\nimport { getConfigArgValue } from '../../../common/utilities/configurable-operation-utils';\r\nimport { ComponentRegistryService } from '../../../providers/component-registry/component-registry.service';\r\n\r\ntype InputListItem = {\r\n    id: number;\r\n    componentRef?: ComponentRef<FormInputComponent>;\r\n    control: FormControl;\r\n};\r\n\r\n/**\r\n * A host component which delegates to an instance or list of FormInputComponent components.\r\n */\r\n@Component({\r\n    selector: 'vdr-dynamic-form-input',\r\n    templateUrl: './dynamic-form-input.component.html',\r\n    styleUrls: ['./dynamic-form-input.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    providers: [\r\n        {\r\n            provide: NG_VALUE_ACCESSOR,\r\n            useExisting: DynamicFormInputComponent,\r\n            multi: true,\r\n        },\r\n    ],\r\n})\r\nexport class DynamicFormInputComponent\r\n    implements OnInit, OnChanges, AfterViewInit, OnDestroy, ControlValueAccessor\r\n{\r\n    @Input() def: ConfigArgDefinition | CustomFieldConfig;\r\n    @Input() readonly: boolean;\r\n    @Input() control: FormControl;\r\n    @ViewChild('single', { read: ViewContainerRef }) singleViewContainer: ViewContainerRef;\r\n    @ViewChildren('listItem', { read: ViewContainerRef }) listItemContainers: QueryList<ViewContainerRef>;\r\n    renderAsList = false;\r\n    listItems: InputListItem[] = [];\r\n    private singleComponentRef: ComponentRef<FormInputComponent>;\r\n    private listId = 1;\r\n    private listFormArray = new FormArray([]);\r\n    private componentType: Type<FormInputComponent>;\r\n    private onChange: (val: any) => void;\r\n    private onTouch: () => void;\r\n    private renderList$ = new Subject();\r\n    private destroy$ = new Subject();\r\n\r\n    constructor(\r\n        private componentRegistryService: ComponentRegistryService,\r\n        private componentFactoryResolver: ComponentFactoryResolver,\r\n        private changeDetectorRef: ChangeDetectorRef,\r\n        private injector: Injector,\r\n    ) {}\r\n\r\n    ngOnInit() {\r\n        const componentId = this.getInputComponentConfig(this.def).component;\r\n        const componentType = this.componentRegistryService.getInputComponent(componentId);\r\n        if (componentType) {\r\n            this.componentType = componentType;\r\n        } else {\r\n            // tslint:disable-next-line:no-console\r\n            console.error(\r\n                `No form input component registered with the id \"${componentId}\". Using the default input instead.`,\r\n            );\r\n            const defaultComponentType = this.componentRegistryService.getInputComponent(\r\n                this.getInputComponentConfig({ ...this.def, ui: undefined } as any).component,\r\n            );\r\n            if (defaultComponentType) {\r\n                this.componentType = defaultComponentType;\r\n            }\r\n        }\r\n    }\r\n\r\n    ngAfterViewInit() {\r\n        if (this.componentType) {\r\n            const factory = this.componentFactoryResolver.resolveComponentFactory(this.componentType);\r\n\r\n            // create a temp instance to check the value of `isListInput`\r\n            const cmpRef = factory.create(this.injector);\r\n            const isListInputComponent = cmpRef.instance.isListInput ?? false;\r\n            cmpRef.destroy();\r\n\r\n            if (this.def.list === false && isListInputComponent) {\r\n                throw new Error(\r\n                    `The ${this.componentType.name} component is a list input, but the definition for ${this.def.name} does not expect a list`,\r\n                );\r\n            }\r\n            this.renderAsList = this.def.list && !isListInputComponent;\r\n            if (!this.renderAsList) {\r\n                this.singleComponentRef = this.renderInputComponent(\r\n                    factory,\r\n                    this.singleViewContainer,\r\n                    this.control,\r\n                );\r\n            } else {\r\n                let formArraySub: Subscription | undefined;\r\n                const renderListInputs = (viewContainerRefs: QueryList<ViewContainerRef>) => {\r\n                    if (viewContainerRefs.length) {\r\n                        if (formArraySub) {\r\n                            formArraySub.unsubscribe();\r\n                        }\r\n                        this.listFormArray = new FormArray([]);\r\n                        this.listItems.forEach(i => i.componentRef?.destroy());\r\n                        viewContainerRefs.forEach((ref, i) => {\r\n                            const listItem = this.listItems?.[i];\r\n                            if (listItem) {\r\n                                this.listFormArray.push(listItem.control);\r\n                                listItem.componentRef = this.renderInputComponent(\r\n                                    factory,\r\n                                    ref,\r\n                                    listItem.control,\r\n                                );\r\n                            }\r\n                        });\r\n\r\n                        formArraySub = this.listFormArray.valueChanges\r\n                            .pipe(takeUntil(this.destroy$))\r\n                            .subscribe(val => {\r\n                                this.control.markAsTouched();\r\n                                this.control.markAsDirty();\r\n                                this.onChange(val);\r\n                                this.control.patchValue(val, { emitEvent: false });\r\n                            });\r\n                        setTimeout(() => this.changeDetectorRef.markForCheck());\r\n                    }\r\n                };\r\n\r\n                // initial render\r\n                this.listItemContainers.changes\r\n                    .pipe(take(1))\r\n                    .subscribe(val => renderListInputs(this.listItemContainers));\r\n\r\n                // render on changes to the list\r\n                this.renderList$\r\n                    .pipe(\r\n                        switchMap(() => this.listItemContainers.changes.pipe(take(1))),\r\n                        takeUntil(this.destroy$),\r\n                    )\r\n                    .subscribe(() => {\r\n                        renderListInputs(this.listItemContainers);\r\n                    });\r\n            }\r\n        }\r\n        setTimeout(() => this.changeDetectorRef.markForCheck());\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges) {\r\n        if (this.listItems) {\r\n            for (const item of this.listItems) {\r\n                if (item.componentRef) {\r\n                    this.updateBindings(changes, item.componentRef);\r\n                }\r\n            }\r\n        }\r\n        if (this.singleComponentRef) {\r\n            this.updateBindings(changes, this.singleComponentRef);\r\n        }\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    private updateBindings(changes: SimpleChanges, componentRef: ComponentRef<FormInputComponent>) {\r\n        if ('def' in changes) {\r\n            componentRef.instance.config = simpleDeepClone(this.def);\r\n        }\r\n        if ('readonly' in changes) {\r\n            componentRef.instance.readonly = this.readonly;\r\n        }\r\n        componentRef.injector.get(ChangeDetectorRef).markForCheck();\r\n    }\r\n\r\n    trackById(index: number, item: { id: number }) {\r\n        return item.id;\r\n    }\r\n\r\n    addListItem() {\r\n        if (!this.listItems) {\r\n            this.listItems = [];\r\n        }\r\n        this.listItems.push({\r\n            id: this.listId++,\r\n            control: new FormControl((this.def as ConfigArgDefinition).defaultValue ?? null),\r\n        });\r\n        this.renderList$.next();\r\n    }\r\n\r\n    moveListItem(event: CdkDragDrop<InputListItem>) {\r\n        if (this.listItems) {\r\n            moveItemInArray(this.listItems, event.previousIndex, event.currentIndex);\r\n            this.listFormArray.removeAt(event.previousIndex);\r\n            this.listFormArray.insert(event.currentIndex, event.item.data.control);\r\n            this.renderList$.next();\r\n        }\r\n    }\r\n\r\n    removeListItem(item: InputListItem) {\r\n        if (this.listItems) {\r\n            const index = this.listItems.findIndex(i => i === item);\r\n            item.componentRef?.destroy();\r\n            this.listFormArray.removeAt(index);\r\n            this.listItems = this.listItems.filter(i => i !== item);\r\n            this.renderList$.next();\r\n        }\r\n    }\r\n\r\n    private renderInputComponent(\r\n        factory: ComponentFactory<FormInputComponent>,\r\n        viewContainerRef: ViewContainerRef,\r\n        formControl: FormControl,\r\n    ) {\r\n        const componentRef = viewContainerRef.createComponent(factory);\r\n        const { instance } = componentRef;\r\n        instance.config = simpleDeepClone(this.def);\r\n        instance.formControl = formControl;\r\n        instance.readonly = this.readonly;\r\n        componentRef.injector.get(ChangeDetectorRef).markForCheck();\r\n        return componentRef;\r\n    }\r\n\r\n    registerOnChange(fn: any): void {\r\n        this.onChange = fn;\r\n    }\r\n\r\n    registerOnTouched(fn: any): void {\r\n        this.onTouch = fn;\r\n    }\r\n\r\n    writeValue(obj: any): void {\r\n        if (Array.isArray(obj)) {\r\n            if (obj.length === this.listItems.length) {\r\n                obj.forEach((value, index) => {\r\n                    const control = this.listItems[index]?.control;\r\n                    control.patchValue(getConfigArgValue(value), { emitEvent: false });\r\n                });\r\n            } else {\r\n                this.listItems = obj.map(\r\n                    value =>\r\n                        ({\r\n                            id: this.listId++,\r\n                            control: new FormControl(getConfigArgValue(value)),\r\n                        } as InputListItem),\r\n                );\r\n                this.renderList$.next();\r\n            }\r\n        } else {\r\n            this.listItems = [];\r\n            this.renderList$.next();\r\n        }\r\n        this.changeDetectorRef.markForCheck();\r\n    }\r\n\r\n    private getInputComponentConfig(argDef: ConfigArgDefinition | CustomFieldConfig): {\r\n        component: DefaultFormComponentId;\r\n    } {\r\n        if (this.hasUiConfig(argDef) && argDef.ui.component) {\r\n            return argDef.ui;\r\n        }\r\n        const type = argDef?.type as ConfigArgType | CustomFieldType;\r\n        switch (type) {\r\n            case 'string':\r\n            case 'localeString': {\r\n                const hasOptions =\r\n                    !!(this.isConfigArgDef(argDef) && argDef.ui?.options) ||\r\n                    !!(argDef as StringCustomFieldConfig).options;\r\n                if (hasOptions) {\r\n                    return { component: 'select-form-input' };\r\n                } else {\r\n                    return { component: 'text-form-input' };\r\n                }\r\n            }\r\n            case 'text': {\r\n                return { component: 'textarea-form-input' };\r\n            }\r\n            case 'int':\r\n            case 'float':\r\n                return { component: 'number-form-input' };\r\n            case 'boolean':\r\n                return { component: 'boolean-form-input' };\r\n            case 'datetime':\r\n                return { component: 'date-form-input' };\r\n            case 'ID':\r\n                return { component: 'text-form-input' };\r\n            case 'relation':\r\n                return { component: 'relation-form-input' };\r\n            default:\r\n                assertNever(type);\r\n        }\r\n    }\r\n\r\n    private isConfigArgDef(def: ConfigArgDefinition | CustomFieldConfig): def is ConfigArgDefinition {\r\n        return (def as ConfigArgDefinition)?.__typename === 'ConfigArgDefinition';\r\n    }\r\n\r\n    private hasUiConfig(def: unknown): def is { ui: { component: string } } {\r\n        return typeof def === 'object' && typeof (def as any)?.ui?.component === 'string';\r\n    }\r\n}\r\n"]}