@ajf/material 13.0.0-next.2 → 13.0.0-rc.1

package/esm2020/form-builder/condition-editor.mjs

@@ -0,0 +1,147 @@
+/**
+ * @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 { AjfFieldType, AjfValidationService } from '@ajf/core/forms';
+import { AjfExpressionUtils } from '@ajf/core/models';
+import { AjfMonacoEditor } from '@ajf/material/monaco-editor';
+import { ChangeDetectionStrategy, Component, Input, ViewChild, ViewEncapsulation, } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ajf/core/forms";
+import * as i2 from "@ajf/material/monaco-editor";
+import * as i3 from "@angular/material/list";
+import * as i4 from "@ajf/material/node-icon";
+import * as i5 from "@angular/common";
+import * as i6 from "@angular/material/tooltip";
+export class AjfFbConditionEditor {
+    constructor(_) { }
+    get fields() {
+        return this._fields;
+    }
+    set fields(fields) {
+        this._fields = fields;
+        this._updateVariables();
+    }
+    insertVariable(variable) {
+        if (this.monacoEditor != null && this.monacoEditor.editor != null) {
+            const editor = this.monacoEditor.editor;
+            let value = editor.getValue().split('\n');
+            let position = editor.getPosition();
+            const ln = position.lineNumber - 1;
+            let line = value[ln];
+            let col = position.column - 1;
+            line = line.substring(0, col) + variable + line.substring(col);
+            value[ln] = line;
+            position.column += variable.length;
+            this.monacoEditor.value = value.join('\n');
+            editor.setPosition(position);
+            editor.focus();
+            this.editedValue = editor.getValue();
+        }
+    }
+    onEditorInit() {
+        monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({
+            noSemanticValidation: false,
+            noSyntaxValidation: false,
+        });
+        monaco.languages.typescript.javascriptDefaults.setCompilerOptions({
+            target: monaco.languages.typescript.ScriptTarget.ES2015,
+            allowNonTsExtensions: true,
+            allowJs: true,
+            module: monaco.languages.typescript.ModuleKind.None,
+        });
+        try {
+            monaco.languages.typescript.javascriptDefaults.addExtraLib('', 'condition-editor-variables.d.ts');
+        }
+        catch (e) {
+            monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-variables.d.ts'] =
+                '';
+        }
+        try {
+            monaco.languages.typescript.javascriptDefaults.addExtraLib('', 'condition-editor-functions.d.ts');
+        }
+        catch (e) {
+            monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-functions.d.ts'] =
+                '';
+        }
+        this._updateVariables();
+        this._updateFunctions();
+    }
+    _updateVariables() {
+        if (this._fields == null) {
+            return;
+        }
+        try {
+            monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-variables.d.ts'] =
+                this._fields
+                    .map((field) => {
+                    return `declare const ${field.name}: ${this._fieldVarType(field.fieldType)};`;
+                })
+                    .join('\n');
+        }
+        catch (e) { }
+    }
+    _updateFunctions() {
+        try {
+            monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-functions.d.ts'] =
+                AjfExpressionUtils.UTIL_FUNCTIONS;
+        }
+        catch (e) { }
+    }
+    _fieldVarType(fieldType) {
+        switch (fieldType) {
+            case AjfFieldType.Boolean:
+                return 'boolean';
+            case AjfFieldType.Date:
+            case AjfFieldType.DateInput:
+            case AjfFieldType.Time:
+                return 'Date';
+            case AjfFieldType.Empty:
+                return 'void';
+            case AjfFieldType.Formula:
+                return 'number';
+            case AjfFieldType.MultipleChoice:
+            case AjfFieldType.SingleChoice:
+                return 'any';
+            case AjfFieldType.Number:
+                return 'number';
+            case AjfFieldType.Table:
+                return 'Array';
+            case AjfFieldType.String:
+            case AjfFieldType.Text:
+                return 'string';
+        }
+        return null;
+    }
+}
+AjfFbConditionEditor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFbConditionEditor, deps: [{ token: i1.AjfValidationService }], target: i0.ɵɵFactoryTarget.Component });
+AjfFbConditionEditor.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0-rc.3", type: AjfFbConditionEditor, selector: "ajf-condition-editor", inputs: { fields: "fields", condition: "condition" }, viewQueries: [{ propertyName: "monacoEditor", first: true, predicate: AjfMonacoEditor, descendants: true, static: true }], ngImport: i0, template: "<div class=\"ajf-editor\">\n  <ajf-monaco-editor\n      (init)=\"onEditorInit()\"\n      (valueChange)=\"editedValue = $event\"\n      [value]=\"condition\" language=\"javascript\"></ajf-monaco-editor>\n</div>\n<div class=\"ajf-editor-panel\">\n  <ng-container *ngIf=\"fields as curFields\">\n    <mat-nav-list dense *ngIf=\"curFields!.length > 0\">\n      <a mat-list-item\n          (click)=\"insertVariable(field.name)\"\n          [matTooltip]=\"field.label\"\n          *ngFor=\"let field of curFields!\">\n        <ajf-node-icon [node]=\"field\"></ajf-node-icon>\n        {{ field.name }}\n      </a>\n    </mat-nav-list>\n  </ng-container>\n</div>\n", styles: ["ajf-condition-editor{display:flex;flex-direction:row;align-items:stretch;max-height:512px}ajf-condition-editor .ajf-editor{flex:.75 0 auto;display:flex;flex-direction:row;align-items:stretch}ajf-condition-editor .ajf-editor monaco-editor{flex:1 0 auto;min-width:512px;min-height:256px}ajf-condition-editor .ajf-editor-panel{flex:.25 0 auto;overflow-y:auto}ajf-condition-editor ajf-monaco-editor{min-width:400px}\n"], components: [{ type: i2.AjfMonacoEditor, selector: "ajf-monaco-editor", inputs: ["experimentalScreenReader", "ariaLabel", "rulers", "wordSeparators", "selectionClipboard", "lineNumbers", "selectOnLineNumbers", "lineNumbersMinChars", "glyphMargin", "lineDecorationsWidth", "revealHorizontalRightPadding", "roundedSelection", "theme", "readOnly", "scrollbar", "overviewRulerLanes", "cursorBlinking", "mouseWheelZoom", "cursorStyle", "fontLigatures", "disableTranslate3d", "hideCursorInOverviewRuler", "scrollBeyondLastLine", "automaticLayout", "wrappingColumn", "wordWrap", "wrappingIndent", "wordWrapBreakBeforeCharacters", "wordWrapBreakAfterCharacters", "wordWrapBreakObtrusiveCharacters", "stopRenderingLineAfter", "hover", "contextmenu", "mouseWheelScrollSensitivity", "quickSuggestions", "quickSuggestionsDelay", "parameterHints", "iconsInSuggestions", "autoClosingBrackets", "formatOnType", "suggestOnTriggerCharacters", "acceptSuggestionOnEnter", "snippetSuggestions", "tabCompletion", "wordBasedSuggestions", "selectionHighlight", "codeLens", "folding", "renderWhitespace", "renderControlCharacters", "renderIndentGuides", "renderLineHighlight", "useTabStops", "fontFamily", "fontWeight", "fontSize", "lineHeight", "language", "disableAutocomplete", "autoFormatOnLoad", "monacoLibPath", "valueToCompare", "value"], outputs: ["valueChange", "valueToCompareChange", "init"] }, { type: i3.MatNavList, selector: "mat-nav-list", inputs: ["disableRipple", "disabled"], exportAs: ["matNavList"] }, { type: i3.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["disableRipple", "disabled"], exportAs: ["matListItem"] }, { type: i4.AjfNodeIcon, selector: "ajf-node-icon" }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i6.MatTooltip, selector: "[matTooltip]", exportAs: ["matTooltip"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFbConditionEditor, decorators: [{
+            type: Component,
+            args: [{ selector: 'ajf-condition-editor', changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<div class=\"ajf-editor\">\n  <ajf-monaco-editor\n      (init)=\"onEditorInit()\"\n      (valueChange)=\"editedValue = $event\"\n      [value]=\"condition\" language=\"javascript\"></ajf-monaco-editor>\n</div>\n<div class=\"ajf-editor-panel\">\n  <ng-container *ngIf=\"fields as curFields\">\n    <mat-nav-list dense *ngIf=\"curFields!.length > 0\">\n      <a mat-list-item\n          (click)=\"insertVariable(field.name)\"\n          [matTooltip]=\"field.label\"\n          *ngFor=\"let field of curFields!\">\n        <ajf-node-icon [node]=\"field\"></ajf-node-icon>\n        {{ field.name }}\n      </a>\n    </mat-nav-list>\n  </ng-container>\n</div>\n", styles: ["ajf-condition-editor{display:flex;flex-direction:row;align-items:stretch;max-height:512px}ajf-condition-editor .ajf-editor{flex:.75 0 auto;display:flex;flex-direction:row;align-items:stretch}ajf-condition-editor .ajf-editor monaco-editor{flex:1 0 auto;min-width:512px;min-height:256px}ajf-condition-editor .ajf-editor-panel{flex:.25 0 auto;overflow-y:auto}ajf-condition-editor ajf-monaco-editor{min-width:400px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AjfValidationService }]; }, propDecorators: { monacoEditor: [{
+                type: ViewChild,
+                args: [AjfMonacoEditor, { static: true }]
+            }], fields: [{
+                type: Input
+            }], condition: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"condition-editor.js","sourceRoot":"","sources":["../../../../../../src/material/form-builder/condition-editor.ts","../../../../../../src/material/form-builder/fb-condition-editor.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (C) Gnucoop soc. coop.\n *\n * This file is part of the Advanced JSON forms (ajf).\n *\n * Advanced JSON forms (ajf) is free software: you can redistribute it and/or\n * modify it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the License,\n * or (at your option) any later version.\n *\n * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero\n * General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Advanced JSON forms (ajf).\n * If not, see http://www.gnu.org/licenses/.\n *\n */\n\nimport {AjfField, AjfFieldType, AjfValidationService} from '@ajf/core/forms';\nimport {AjfExpressionUtils} from '@ajf/core/models';\nimport {AjfMonacoEditor} from '@ajf/material/monaco-editor';\nimport {\n  ChangeDetectionStrategy,\n  Component,\n  Input,\n  ViewChild,\n  ViewEncapsulation,\n} from '@angular/core';\n\ndeclare var monaco: any;\n\n@Component({\n  selector: 'ajf-condition-editor',\n  templateUrl: 'fb-condition-editor.html',\n  styleUrls: ['fb-condition-editor.css'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None,\n})\nexport class AjfFbConditionEditor {\n  @ViewChild(AjfMonacoEditor, {static: true}) monacoEditor: AjfMonacoEditor;\n\n  private _fields: AjfField[];\n  get fields(): AjfField[] {\n    return this._fields;\n  }\n  @Input()\n  set fields(fields: AjfField[]) {\n    this._fields = fields;\n    this._updateVariables();\n  }\n  @Input() condition: string;\n\n  editedValue: string;\n\n  constructor(_: AjfValidationService) {}\n\n  insertVariable(variable: string): void {\n    if (this.monacoEditor != null && this.monacoEditor.editor != null) {\n      const editor = this.monacoEditor.editor;\n      let value: string[] = editor.getValue().split('\\n');\n      let position: {column: number; lineNumber: number} = editor.getPosition();\n      const ln = position.lineNumber - 1;\n      let line = value[ln];\n      let col = position.column - 1;\n      line = line.substring(0, col) + variable + line.substring(col);\n      value[ln] = line;\n      position.column += variable.length;\n      this.monacoEditor.value = value.join('\\n');\n      editor.setPosition(position);\n      editor.focus();\n      this.editedValue = editor.getValue();\n    }\n  }\n\n  onEditorInit(): void {\n    monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions({\n      noSemanticValidation: false,\n      noSyntaxValidation: false,\n    });\n\n    monaco.languages.typescript.javascriptDefaults.setCompilerOptions({\n      target: monaco.languages.typescript.ScriptTarget.ES2015,\n      allowNonTsExtensions: true,\n      allowJs: true,\n      module: monaco.languages.typescript.ModuleKind.None,\n    });\n\n    try {\n      monaco.languages.typescript.javascriptDefaults.addExtraLib(\n        '',\n        'condition-editor-variables.d.ts',\n      );\n    } catch (e) {\n      monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-variables.d.ts'] =\n        '';\n    }\n\n    try {\n      monaco.languages.typescript.javascriptDefaults.addExtraLib(\n        '',\n        'condition-editor-functions.d.ts',\n      );\n    } catch (e) {\n      monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-functions.d.ts'] =\n        '';\n    }\n\n    this._updateVariables();\n    this._updateFunctions();\n  }\n\n  private _updateVariables(): void {\n    if (this._fields == null) {\n      return;\n    }\n    try {\n      monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-variables.d.ts'] =\n        this._fields\n          .map((field: AjfField) => {\n            return `declare const ${field.name}: ${this._fieldVarType(field.fieldType)};`;\n          })\n          .join('\\n');\n    } catch (e) {}\n  }\n\n  private _updateFunctions(): void {\n    try {\n      monaco.languages.typescript.javascriptDefaults._extraLibs['condition-editor-functions.d.ts'] =\n        AjfExpressionUtils.UTIL_FUNCTIONS;\n    } catch (e) {}\n  }\n\n  private _fieldVarType(fieldType: AjfFieldType): string | null {\n    switch (fieldType) {\n      case AjfFieldType.Boolean:\n        return 'boolean';\n      case AjfFieldType.Date:\n      case AjfFieldType.DateInput:\n      case AjfFieldType.Time:\n        return 'Date';\n      case AjfFieldType.Empty:\n        return 'void';\n      case AjfFieldType.Formula:\n        return 'number';\n      case AjfFieldType.MultipleChoice:\n      case AjfFieldType.SingleChoice:\n        return 'any';\n      case AjfFieldType.Number:\n        return 'number';\n      case AjfFieldType.Table:\n        return 'Array';\n      case AjfFieldType.String:\n      case AjfFieldType.Text:\n        return 'string';\n    }\n    return null;\n  }\n}\n","<div class=\"ajf-editor\">\n  <ajf-monaco-editor\n      (init)=\"onEditorInit()\"\n      (valueChange)=\"editedValue = $event\"\n      [value]=\"condition\" language=\"javascript\"></ajf-monaco-editor>\n</div>\n<div class=\"ajf-editor-panel\">\n  <ng-container *ngIf=\"fields as curFields\">\n    <mat-nav-list dense *ngIf=\"curFields!.length > 0\">\n      <a mat-list-item\n          (click)=\"insertVariable(field.name)\"\n          [matTooltip]=\"field.label\"\n          *ngFor=\"let field of curFields!\">\n        <ajf-node-icon [node]=\"field\"></ajf-node-icon>\n        {{ field.name }}\n      </a>\n    </mat-nav-list>\n  </ng-container>\n</div>\n"]}

package/esm2020/form-builder/form-builder-module.mjs

@@ -0,0 +1,179 @@
+/**
+ * @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 { AjfTranslocoModule } from '@ajf/core/transloco';
+import { AjfMonacoEditorModule } from '@ajf/material/monaco-editor';
+import { AjfNodeIconModule } from '@ajf/material/node-icon';
+import { DragDropModule } from '@angular/cdk/drag-drop';
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSidenavModule } from '@angular/material/sidenav';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatTableModule } from '@angular/material/table';
+import { MatToolbarModule } from '@angular/material/toolbar';
+import { MatTooltipModule } from '@angular/material/tooltip';
+import { AjfFbBranchLine } from './branch-line';
+import { AjfFbChoicesOriginEditor } from './choices-origin-editor';
+import { AjfFbChoicesOriginEditorDialog } from './choices-origin-editor-dialog';
+import { AjfFbConditionEditor } from './condition-editor';
+import { AjfFbConditionEditorDialog } from './condition-editor-dialog';
+import { AjfFormBuilder } from './form-builder';
+import { AjfFormBuilderService } from './form-builder-service';
+import { AjfFbNodeEntry } from './node-entry';
+import { AjfFbNodeProperties } from './node-properties';
+import { AjfFbNodeTypeEntry } from './node-type-entry';
+import { AjfFbStringIdentifierDialogComponent } from './string-identifier-dialog';
+import { AjfFbValidationConditionEditorDialog } from './validation-condition-editor-dialog';
+import { AjfFbWarningConditionEditorDialog } from './warning-condition-editor-dialog';
+import * as i0 from "@angular/core";
+export class AjfFormBuilderModule {
+}
+AjfFormBuilderModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFormBuilderModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AjfFormBuilderModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFormBuilderModule, declarations: [AjfFbBranchLine,
+        AjfFbChoicesOriginEditor,
+        AjfFbChoicesOriginEditorDialog,
+        AjfFbConditionEditor,
+        AjfFbConditionEditorDialog,
+        AjfFbNodeEntry,
+        AjfFbNodeProperties,
+        AjfFbNodeTypeEntry,
+        AjfFbStringIdentifierDialogComponent,
+        AjfFbValidationConditionEditorDialog,
+        AjfFbWarningConditionEditorDialog,
+        AjfFormBuilder], imports: [AjfMonacoEditorModule,
+        AjfNodeIconModule,
+        CommonModule,
+        DragDropModule,
+        FormsModule,
+        MatAutocompleteModule,
+        MatButtonModule,
+        MatCardModule,
+        MatCheckboxModule,
+        MatChipsModule,
+        MatDialogModule,
+        MatFormFieldModule,
+        MatIconModule,
+        MatInputModule,
+        MatListModule,
+        MatMenuModule,
+        MatSelectModule,
+        MatSidenavModule,
+        MatSliderModule,
+        MatTableModule,
+        MatToolbarModule,
+        MatTooltipModule,
+        ReactiveFormsModule,
+        AjfTranslocoModule,
+        MatExpansionModule,
+        MatSlideToggleModule], exports: [AjfFormBuilder] });
+AjfFormBuilderModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFormBuilderModule, providers: [AjfFormBuilderService], imports: [[
+            AjfMonacoEditorModule,
+            AjfNodeIconModule,
+            CommonModule,
+            DragDropModule,
+            FormsModule,
+            MatAutocompleteModule,
+            MatButtonModule,
+            MatCardModule,
+            MatCheckboxModule,
+            MatChipsModule,
+            MatDialogModule,
+            MatFormFieldModule,
+            MatIconModule,
+            MatInputModule,
+            MatListModule,
+            MatMenuModule,
+            MatSelectModule,
+            MatSidenavModule,
+            MatSliderModule,
+            MatTableModule,
+            MatToolbarModule,
+            MatTooltipModule,
+            ReactiveFormsModule,
+            AjfTranslocoModule,
+            MatExpansionModule,
+            MatSlideToggleModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-rc.3", ngImport: i0, type: AjfFormBuilderModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        AjfMonacoEditorModule,
+                        AjfNodeIconModule,
+                        CommonModule,
+                        DragDropModule,
+                        FormsModule,
+                        MatAutocompleteModule,
+                        MatButtonModule,
+                        MatCardModule,
+                        MatCheckboxModule,
+                        MatChipsModule,
+                        MatDialogModule,
+                        MatFormFieldModule,
+                        MatIconModule,
+                        MatInputModule,
+                        MatListModule,
+                        MatMenuModule,
+                        MatSelectModule,
+                        MatSidenavModule,
+                        MatSliderModule,
+                        MatTableModule,
+                        MatToolbarModule,
+                        MatTooltipModule,
+                        ReactiveFormsModule,
+                        AjfTranslocoModule,
+                        MatExpansionModule,
+                        MatSlideToggleModule,
+                    ],
+                    declarations: [
+                        AjfFbBranchLine,
+                        AjfFbChoicesOriginEditor,
+                        AjfFbChoicesOriginEditorDialog,
+                        AjfFbConditionEditor,
+                        AjfFbConditionEditorDialog,
+                        AjfFbNodeEntry,
+                        AjfFbNodeProperties,
+                        AjfFbNodeTypeEntry,
+                        AjfFbStringIdentifierDialogComponent,
+                        AjfFbValidationConditionEditorDialog,
+                        AjfFbWarningConditionEditorDialog,
+                        AjfFormBuilder,
+                    ],
+                    exports: [AjfFormBuilder],
+                    providers: [AjfFormBuilderService],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-builder-module.js","sourceRoot":"","sources":["../../../../../../src/material/form-builder/form-builder-module.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright (C) Gnucoop soc. coop.\n *\n * This file is part of the Advanced JSON forms (ajf).\n *\n * Advanced JSON forms (ajf) is free software: you can redistribute it and/or\n * modify it under the terms of the GNU Affero General Public License as\n * published by the Free Software Foundation, either version 3 of the License,\n * or (at your option) any later version.\n *\n * Advanced JSON forms (ajf) is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero\n * General Public License for more details.\n *\n * You should have received a copy of the GNU Affero General Public License\n * along with Advanced JSON forms (ajf).\n * If not, see http://www.gnu.org/licenses/.\n *\n */\n\nimport {AjfTranslocoModule} from '@ajf/core/transloco';\nimport {AjfMonacoEditorModule} from '@ajf/material/monaco-editor';\nimport {AjfNodeIconModule} from '@ajf/material/node-icon';\nimport {DragDropModule} from '@angular/cdk/drag-drop';\nimport {CommonModule} from '@angular/common';\nimport {NgModule} from '@angular/core';\nimport {FormsModule, ReactiveFormsModule} from '@angular/forms';\nimport {MatAutocompleteModule} from '@angular/material/autocomplete';\nimport {MatButtonModule} from '@angular/material/button';\nimport {MatCardModule} from '@angular/material/card';\nimport {MatCheckboxModule} from '@angular/material/checkbox';\nimport {MatChipsModule} from '@angular/material/chips';\nimport {MatDialogModule} from '@angular/material/dialog';\nimport {MatExpansionModule} from '@angular/material/expansion';\nimport {MatFormFieldModule} from '@angular/material/form-field';\nimport {MatIconModule} from '@angular/material/icon';\nimport {MatInputModule} from '@angular/material/input';\nimport {MatListModule} from '@angular/material/list';\nimport {MatMenuModule} from '@angular/material/menu';\nimport {MatSelectModule} from '@angular/material/select';\nimport {MatSidenavModule} from '@angular/material/sidenav';\nimport {MatSlideToggleModule} from '@angular/material/slide-toggle';\nimport {MatSliderModule} from '@angular/material/slider';\nimport {MatTableModule} from '@angular/material/table';\nimport {MatToolbarModule} from '@angular/material/toolbar';\nimport {MatTooltipModule} from '@angular/material/tooltip';\n\nimport {AjfFbBranchLine} from './branch-line';\nimport {AjfFbChoicesOriginEditor} from './choices-origin-editor';\nimport {AjfFbChoicesOriginEditorDialog} from './choices-origin-editor-dialog';\nimport {AjfFbConditionEditor} from './condition-editor';\nimport {AjfFbConditionEditorDialog} from './condition-editor-dialog';\nimport {AjfFormBuilder} from './form-builder';\nimport {AjfFormBuilderService} from './form-builder-service';\nimport {AjfFbNodeEntry} from './node-entry';\nimport {AjfFbNodeProperties} from './node-properties';\nimport {AjfFbNodeTypeEntry} from './node-type-entry';\nimport {AjfFbStringIdentifierDialogComponent} from './string-identifier-dialog';\nimport {AjfFbValidationConditionEditorDialog} from './validation-condition-editor-dialog';\nimport {AjfFbWarningConditionEditorDialog} from './warning-condition-editor-dialog';\n\n@NgModule({\n  imports: [\n    AjfMonacoEditorModule,\n    AjfNodeIconModule,\n    CommonModule,\n    DragDropModule,\n    FormsModule,\n    MatAutocompleteModule,\n    MatButtonModule,\n    MatCardModule,\n    MatCheckboxModule,\n    MatChipsModule,\n    MatDialogModule,\n    MatFormFieldModule,\n    MatIconModule,\n    MatInputModule,\n    MatListModule,\n    MatMenuModule,\n    MatSelectModule,\n    MatSidenavModule,\n    MatSliderModule,\n    MatTableModule,\n    MatToolbarModule,\n    MatTooltipModule,\n    ReactiveFormsModule,\n    AjfTranslocoModule,\n    MatExpansionModule,\n    MatSlideToggleModule,\n  ],\n  declarations: [\n    AjfFbBranchLine,\n    AjfFbChoicesOriginEditor,\n    AjfFbChoicesOriginEditorDialog,\n    AjfFbConditionEditor,\n    AjfFbConditionEditorDialog,\n    AjfFbNodeEntry,\n    AjfFbNodeProperties,\n    AjfFbNodeTypeEntry,\n    AjfFbStringIdentifierDialogComponent,\n    AjfFbValidationConditionEditorDialog,\n    AjfFbWarningConditionEditorDialog,\n    AjfFormBuilder,\n  ],\n  exports: [AjfFormBuilder],\n  providers: [AjfFormBuilderService],\n})\nexport class AjfFormBuilderModule {}\n"]}