@ajf/material 15.3.4 → 15.3.5

package/esm2020/form-builder/node-properties-name-validator.mjs

@@ -0,0 +1,64 @@
+/**
+ * @license
+ * Copyright (C) Gnucoop soc. coop.
+ *
+ * This file is part of the Advanced JSON forms (ajf).
+ *
+ * Advanced JSON forms (ajf) is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with Advanced JSON forms (ajf).
+ * If not, see http://www.gnu.org/licenses/.
+ *
+ */
+import { Injectable } from '@angular/core';
+import { of } from 'rxjs';
+import { debounceTime, finalize, map, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./form-builder-service";
+/**
+ * Custom validator service that checks for an already existing
+ * Node with the given name.
+ */
+export class AjfNodePropertiesNameMatchValidator {
+    constructor(_fbs) {
+        this._fbs = _fbs;
+    }
+    /**
+     * Custom async validator method.
+     * Checks if a Node with the same Name exists, in order to
+     * validate the Node Entry properties form.
+     * @param cdr The editor changeDetectionRef
+     * @param currentId The current node entry id
+     */
+    sameValueCheck(cdr, currentId) {
+        return (control) => {
+            if (!this._fbs.flatNodes)
+                return of(null);
+            return this._fbs.flatNodes.pipe(debounceTime(300), map(nodes => {
+                const sameNameNode = nodes.find(n => n.name.toLowerCase() === control.value.toLowerCase() && n.id != currentId);
+                if (sameNameNode) {
+                    return { 'name_exists': true };
+                }
+                return null;
+            }), finalize(() => {
+                control.markAsTouched();
+                cdr.detectChanges();
+            }), take(1));
+        };
+    }
+}
+AjfNodePropertiesNameMatchValidator.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AjfNodePropertiesNameMatchValidator, deps: [{ token: i1.AjfFormBuilderService }], target: i0.ɵɵFactoryTarget.Injectable });
+AjfNodePropertiesNameMatchValidator.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AjfNodePropertiesNameMatchValidator });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.0.4", ngImport: i0, type: AjfNodePropertiesNameMatchValidator, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AjfFormBuilderService }]; } });
+//# sourceMappingURL=data:application/json;base64,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