@ajf/material 13.0.0-next.0

package/esm2015/form-builder/condition-editor.js

@@ -0,0 +1,143 @@
+/**
+ * @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';
+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.decorators = [
+    { type: Component, args: [{
+                selector: 'ajf-condition-editor',
+                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",
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                encapsulation: ViewEncapsulation.None,
+                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"]
+            },] }
+];
+AjfFbConditionEditor.ctorParameters = () => [
+    { type: AjfValidationService }
+];
+AjfFbConditionEditor.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"],"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, noSyntaxValidation: false});\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          '', 'condition-editor-variables.d.ts');\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          '', 'condition-editor-functions.d.ts');\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\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\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"]}

package/esm2015/form-builder/form-builder-module.js

@@ -0,0 +1,96 @@
+/**
+ * @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';
+export class AjfFormBuilderModule {
+}
+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, AjfNodeIconModule,     CommonModule,        DragDropModule,\n    FormsModule,           MatAutocompleteModule, MatButtonModule,     MatCardModule,\n    MatCheckboxModule,     MatChipsModule,        MatDialogModule,     MatFormFieldModule,\n    MatIconModule,         MatInputModule,        MatListModule,       MatMenuModule,\n    MatSelectModule,       MatSidenavModule,      MatSliderModule,     MatTableModule,\n    MatToolbarModule,      MatTooltipModule,      ReactiveFormsModule, AjfTranslocoModule,\n    MatExpansionModule,    MatSlideToggleModule,\n\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: [\n    AjfFormBuilder,\n  ],\n  providers: [\n    AjfFormBuilderService,\n  ],\n})\nexport class AjfFormBuilderModule {\n}\n"]}