@vgip/meta-ui 2.1.1 → 2.1.3

package/.eslintrc.json

@@ -0,0 +1,57 @@
+{
+  "extends": "../../.eslintrc.json",
+  "ignorePatterns": [
+    "!**/*"
+  ],
+  "overrides": [
+    {
+      "files": [
+        "*.ts"
+      ],
+      "parserOptions": {
+        "project": [
+          "projects/meta-ui/tsconfig.lib.json",
+          "projects/meta-ui/tsconfig.spec.json"
+        ],
+        "createDefaultProgram": true
+      },
+      "rules": {
+        "@angular-eslint/component-class-suffix": "off",
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": "element",
+            "prefix": "vgip",
+            "style": "kebab-case"
+          }
+        ],
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "meta",
+            "style": "camelCase"
+          }
+        ],
+        "@typescript-eslint/explicit-member-accessibility": [
+          "off",
+          {
+            "accessibility": "explicit"
+          }
+        ],
+        "arrow-parens": [
+          "off",
+          "always"
+        ],
+        "import/order": "off",
+        "no-trailing-spaces": "off"
+      }
+    },
+    {
+      "files": [
+        "*.html"
+      ],
+      "rules": {}
+    }
+  ]
+}

package/karma.conf.js

@@ -0,0 +1,35 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    coverageReporter: {
+      dir : require('path').join(__dirname, '../../coverage/meta-ui'),
+      reporters: [
+        { type: 'html', subdir: 'report-html' },
+        { type: 'lcov', subdir: 'report-lcov' },
+        { type: 'text-summary', subdir: '.', file: 'text-summary.txt' },
+      ]
+    },
+    reporters: ['progress', 'kjhtml', 'coverage'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/ng-package.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/meta-ui",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  },
+  "assets": [
+    "vendor/volta3"
+  ]
+}

package/package.json

@@ -1,26 +1,14 @@
 {
   "name": "@vgip/meta-ui",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "VGIP Meta UI",
   "peerDependencies": {
-    "@angular/common": "^^20.3.5",
+    "@angular/common": "^20.3.5",
     "@angular/core": "^20.3.5",
     "ngx-quill": "^28.0.1",
     "quill": "^2.0.3"
   },
   "dependencies": {
     "tslib": "^2.0.0"
-  },
-  "module": "fesm2022/vgip-meta-ui.mjs",
-  "typings": "index.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./index.d.ts",
-      "default": "./fesm2022/vgip-meta-ui.mjs"
-    }
-  },
-  "sideEffects": false
-}
+  }
+}

package/src/lib/common/fieldNormalizer/boolean.ts

@@ -0,0 +1,11 @@
+export const booleanFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name
+  };
+  if (field.subtype) {
+    f.subtype = field.subtype;
+  }
+  f.type = field.name ? 'boolean' : 'missing name';
+  return f;
+};

package/src/lib/common/fieldNormalizer/datetime.ts

@@ -0,0 +1,8 @@
+export const datetimeFieldNormalizer = (field) => {
+  const f: any = {
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? (field.type || '').toLowerCase() : 'missing name';
+  return f;
+};

package/src/lib/common/fieldNormalizer/index.ts

@@ -0,0 +1,171 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:34:34
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2021-03-22 17:13:53
+ */
+
+import { numberFieldNormalizer } from './number';
+import { optionsFieldNormalizer } from './options';
+import { stringFieldNormalizer } from './string';
+import { booleanFieldNormalizer } from './boolean';
+import { textFieldNormalizer } from './text';
+import { datetimeFieldNormalizer } from './datetime';
+import { referenceFieldNormalizer } from './reference';
+import { radioFieldNormalizer } from './radio';
+import { richtextFieldNormalizer } from './richtext';
+
+import { uniqueNameFilter } from './uniqueNameFilter';
+
+export const fieldNormalizer = (field: any, uniqFieldNames: Array<string>) => {
+  if (!field) {
+    return;
+  }
+  const f: any = {
+    validations: {}
+  };
+  const fieldType = (field.type || '').toLowerCase();
+  if (['int', 'integer', 'number', 'double', 'float', 'bigdecimal', 'percent', 'currency'].indexOf(fieldType) !== -1) {
+    Object.assign(f, numberFieldNormalizer(field));
+  } else if (['picklist', 'select', 'multipicklist', 'options'].indexOf(fieldType) !== -1) {
+    Object.assign(f, optionsFieldNormalizer(field));
+  } else if (['string', null, undefined, '', 'email', 'phone', 'url', 'combobox'].indexOf(fieldType) !== -1) {
+    Object.assign(f, stringFieldNormalizer(field));
+  } else if (['bool', 'boolean', 'checkbox', 'switch'].indexOf(fieldType) !== -1) {
+    Object.assign(f, booleanFieldNormalizer(field));
+  } else if (['text', 'textarea'].indexOf(fieldType) !== -1) {
+    Object.assign(f, textFieldNormalizer(field));
+  } else if (['richtext'].indexOf(fieldType) !== -1) {
+    Object.assign(f, richtextFieldNormalizer(field));
+  } else if (['date', 'time', 'datetime', 'datetime-local'].indexOf(fieldType) !== -1) {
+    Object.assign(f, datetimeFieldNormalizer(field));
+  } else if (['reference', 'references', 'multireference'].indexOf(fieldType) !== -1) {
+    Object.assign(f, referenceFieldNormalizer(field));
+  } else if (['radio'].indexOf(fieldType) !== -1) {
+    Object.assign(f, radioFieldNormalizer(field));
+  } else if (fieldType === 'composite') {
+    Object.assign(f, {
+      type: 'composite',
+      label: field.label,
+      name: field.name,
+      fields: uniqueNameFilter(
+        field.fields || field.reference || [],
+        uniqFieldNames,
+        (typeof(field.name) !== 'undefined')
+      ).map((v) => fieldNormalizer(v, uniqFieldNames))
+    });
+    if (field.subtype) {
+      f.subtype = field.subtype;
+    }
+  } else if (fieldType === 'list') {
+    const list = field.list || field.reference;
+    Object.assign(f, {
+      type: field.name ? 'list' : 'missing name',
+      label: field.label,
+      name: field.name,
+      list: fieldNormalizer(uniqueNameFilter(list, uniqFieldNames), field.name ? [] : uniqFieldNames)
+    });
+    if (field.selectable) {
+      f.selectable = field.selectable;
+    }
+    if (field.resourceType) {
+      f.resourceType = field.resourceType;
+    }
+  } else if (fieldType === 'hidden') {
+    Object.assign(f, {
+      name: field.name,
+      type: 'hidden'
+    });
+  } else {
+    Object.assign(f, {
+      label: field.label,
+      name: field.name,
+      type: `@v2 ${fieldType}`
+    });
+  }
+  if (field.validations) {
+    Object.assign(f.validations, field.validations);
+  }
+  if (field.auto) {
+    f.auto = field.auto;
+  }
+  if ((field.default || field.defaultValue) && !f.default) {
+    const d = field.default || field.defaultValue;
+    if (Array.isArray(d)) {
+      f.default = [];
+      for (const v of d) {
+        if (typeof(v) === 'object' && v !== null) {
+          const o: any = {
+            id: v.id || v.value || v.name || v.label,
+            label: v.label || 'N/A'
+          };
+          if (v.type) {
+            o.type = v.type;
+          }
+          if (!v.type && f.reference && f.reference.name) { // Bullhorn CAND PT bad metadata
+            o.type = f.reference.name;
+          }
+          f.default.push(o);
+        } else {
+          f.default = v;
+        }
+      }
+    } else if (typeof(d) === 'object' && d !== null) {
+      if (field.type === 'boolean' && typeof(d.value) === 'boolean') {
+        f.default = d.value;
+      } else if (Object.keys(d).length) {
+        const id = d.id || d.value || d.name || d.label;
+        if (id) {
+          f.default = {
+            id: d.id || d.value || d.name || d.label,
+            label: d.label || 'N/A'
+          };
+        }
+        if (d.type) {
+          f.default.type = d.type;
+        }
+      }
+    } else {
+      f.default = d;
+    }
+  }
+  if (field.visible || field.alwaysVisible) {
+    f.visible = field.visible || field.alwaysVisible;
+  }
+  if (field.hidden) {
+    f.hidden = field.hidden;
+  }
+  if (field.hint || field.helpText) {
+    f.hint = field.hint || field.helpText;
+  }
+  if (field.valueType) {
+    f.valueType = field.valueType;
+  }
+  if (field.multiple) {
+    f.multiple = field.multiple;
+  }
+  if (field.suggestions && field.suggestions.length) {
+    f.suggestions = field.suggestions;
+  }
+  if (field.updateable === false || field.updatable === false) {
+    if (!f.flags) {
+      f.flags = { updatable: false };
+    } else {
+      f.flags.updatable = false;
+    }
+  }
+  if (field.createable === false || field.creatable === false) {
+    if (!f.flags) {
+      f.flags = { creatable: false };
+    } else {
+      f.flags.creatable = false;
+    }
+  }
+  if (typeof(field.enabled) !== 'undefined') {
+    f.enabled = field.enabled;
+  }
+  if (typeof(field.disabled) !== 'undefined') {
+    f.disabled = field.disabled;
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/number.ts

@@ -0,0 +1,13 @@
+export const numberFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? 'number' : 'missing name';
+  if (field.type === 'float' || field.subtype === 'float') {
+    f.validations = {
+      step: field.step || '0.01'
+    }
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/options.ts

@@ -0,0 +1,48 @@
+export const optionsFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name,
+    options: field.options || []
+  };
+  if (field.dependentPicklist && field.controllerName) {
+    const enabled = {};
+    enabled[field.controllerName] = true;
+    f.enabled = enabled;
+  }
+  if (field.picklist) {
+    for (const o of field.picklist) {
+      const opt: any = {
+        id: o.name || o.id,
+        label: o.label
+      };
+      if (field.for) {
+        opt.for = field.for;
+      }
+      if (o.validFor && field.controllerName) {
+        const validFor = {};
+        validFor[field.controllerName] = o.validFor;
+        opt.for = validFor;
+      }
+      f.options.push(opt);
+      if (o.defaultValue && !field.default) {
+        f.default = opt.id;
+      }
+    }
+  }
+  f.type = field.name ? 'select' : 'missing name';
+  if (field.type === 'multipicklist') {
+    f.multiple = true;
+  }
+  if (field.reference) {
+    f.reference = field.reference;
+  }
+  if (field.searchUrl || field.searchParams) {
+    f.search = {
+      url: field.searchUrl,
+      params: field.searchParams
+    };
+  } else if (field.search) {
+    f.search = field.search;
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/radio.ts

@@ -0,0 +1,29 @@
+export const radioFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name,
+    options: field.options || []
+  };
+  f.type = field.name ? 'radio' : 'missing name';
+  if (field.picklist) {
+    for (const o of field.picklist) {
+      const opt: any = {
+        id: o.name || o.id,
+        label: o.label
+      };
+      if (field.for) {
+        opt.for = field.for;
+      }
+      if (o.validFor && field.controllerName) {
+        const validFor = {};
+        validFor[field.controllerName] = o.validFor;
+        opt.for = validFor;
+      }
+      f.options.push(opt);
+      if (o.defaultValue && !field.default) {
+        f.default = opt.id;
+      }
+    }
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/reference.ts

@@ -0,0 +1,32 @@
+export const referenceFieldNormalizer = (field) => {
+  const f: any =  {
+    type: field.name ? 'reference' : 'missing name',
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? 'reference' : 'missing name';
+  if (field.reference) {
+    if (field.reference instanceof Array && field.reference.length === 1) {
+      f.reference = field.reference[0];
+    } else {
+      f.reference = field.reference;
+    }
+  } else if (field.references) {
+    f.references = field.references;
+  }
+  if (field.acceptNew) {
+    f.acceptNew = field.acceptNew;
+  }
+  if (field.searchLabel) {
+    f.searchLabel = field.searchLabel;
+  }
+  if (field.searchUrl || field.searchParams) {
+    f.search = {
+      url: field.searchUrl,
+      params: field.searchParams
+    };
+  } else if (field.search) {
+    f.search = field.search;
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/richtext.ts

@@ -0,0 +1,15 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com 
+ * @Date: 2019-09-19 17:34:34 
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2021-03-22 17:11:01
+ */
+
+ export const richtextFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? 'richtext' : 'missing name';  
+  return f;
+};

package/src/lib/common/fieldNormalizer/string.ts

@@ -0,0 +1,23 @@
+export const stringFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? 'string' : 'missing name';
+  if (field.subtype) {
+    f.subtype = field.subtype;
+  }
+  if (field.picklist || field.options) {
+    f.suggestions = (field.picklist || field.options || []).map((s) => {
+      if (s.defaultValue) {
+        f.default = s.label || s.name || s.id || s;
+      }
+      return {
+        id: s.id,
+        label: s.label,
+        name: s.name
+      };
+    });
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/text.ts

@@ -0,0 +1,17 @@
+/*
+* @Author: Alexander.Vangelov@vonage.com
+* @Date: 2021-03-22 17:09:52
+* @Last Modified by: Alexander.Vangelov@vonage.com
+* @Last Modified time: 2021-03-22 17:09:52
+*/
+export const textFieldNormalizer = (field) => {
+  const f: any =  {
+    label: field.label,
+    name: field.name
+  };
+  f.type = field.name ? 'text' : 'missing name';
+  if (field.rows) {
+    f.rows = field.rows;
+  }
+  return f;
+};

package/src/lib/common/fieldNormalizer/uniqueNameFilter.ts

@@ -0,0 +1,21 @@
+/*
+* @Author: Alexander.Vangelov@vonage.com
+* @Date: 2021-03-22 17:09:12
+* @Last Modified by: Alexander.Vangelov@vonage.com
+* @Last Modified time: 2021-03-22 17:09:12
+*/
+export const uniqueNameFilter = (fields: Array<any>, uniqFieldNames: Array<string>, allowDuplicates = false) => {
+  if (fields instanceof Array) {
+    return allowDuplicates ? fields : fields.filter((f) => {
+      if (f.name) {
+        if (uniqFieldNames.indexOf(f.name) !== -1) {
+          return false;
+        }
+        uniqFieldNames.push(f.name);
+      }
+      return true;
+    });
+  } else {
+    return fields;
+  }
+};

package/src/lib/common/metaAutofocus.directive.ts

@@ -0,0 +1,31 @@
+/*
+* @Author: Alexander.Vangelov@vonage.com
+* @Date: 2021-02-11 17:25:09
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2021-02-11 17:33:57
+*/
+import { Directive, ElementRef, AfterContentInit, Input } from '@angular/core';
+
+@Directive({
+    // eslint-disable-next-line
+    selector: '[vgipMetaFormAutofocus]',
+    standalone: false
+})
+export class MetaAutofocusDirective implements AfterContentInit {
+  @Input() vgipMetaFormAutofocus: boolean;
+
+  constructor(private elementRef: ElementRef) {}
+
+  ngAfterContentInit(): void {
+    if (this.vgipMetaFormAutofocus) {
+      setTimeout(() => {
+        const firstInput = this.elementRef.nativeElement.querySelector(
+          '.Vlt-form__element:not(.has-value) .main:not(.standalone):not([value])'
+        );
+        if (firstInput) {
+          firstInput.focus();
+        }
+      }, 300);
+    }
+  }
+}

package/src/lib/common/metaContext.resolver.ts

@@ -0,0 +1,25 @@
+/*
+* @Author: Alexander.Vangelov@vonage.com
+* @Date: 2020-05-03 21:09:03
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2020-05-03 21:09:36
+*/
+
+import { Injectable } from '@angular/core';
+import { ActivatedRouteSnapshot } from '@angular/router';
+import { Observable, EMPTY } from 'rxjs';
+
+import { MetaContextService } from '../services/metaContext';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class MetaContextResolver  {
+  constructor(private metaContext: MetaContextService) {}
+
+  resolve(route: ActivatedRouteSnapshot): Observable<any> {
+    this.metaContext.phoneNumber = route.queryParamMap.get('phoneNumber');
+    this.metaContext.displayName = route.queryParamMap.get('displayName');
+    return EMPTY;
+  }
+}

package/src/lib/common/metaIcons.pipe.spec.ts

@@ -0,0 +1,15 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com 
+ * @Date: 2019-09-19 17:35:19 
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2019-11-05 13:46:14
+ */
+
+import { MetaIconsPipe } from './metaIcons.pipe';
+
+describe('VoltaIconsPipe', () => {
+  it('create an instance', () => {
+    const pipe = new MetaIconsPipe({ bypassSecurityTrustHtml: (v) => v } as any);
+    expect(pipe).toBeTruthy();
+  });
+});

package/src/lib/common/metaIcons.pipe.ts

@@ -0,0 +1,29 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2019-11-05 13:46:18
+ */
+
+import { Pipe, PipeTransform } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+
+@Pipe({
+    name: 'metaIcons',
+    standalone: false
+})
+export class MetaIconsPipe implements PipeTransform {
+
+  constructor(protected sanitizer: DomSanitizer) { }
+
+  transform(value: any): any {
+    if (typeof(value) === 'string') {
+      value = value.replace(
+        /\${\s*icon:([\w-]+)\s*}/g,
+        (match, val) => `<svg class='Vlt-icon'><use xlink:href="volta/volta-icons.svg#${val}"/></svg>`
+      );
+      return value; //this.sanitizer.bypassSecurityTrustHtml(value);
+    }
+  }
+
+}

package/src/lib/common/metaModel.pipe.ts

@@ -0,0 +1,19 @@
+/*
+ * @Author: Alexander.Vangelov@vonage.com
+ * @Date: 2019-09-19 17:35:19
+ * @Last Modified by: Alexander.Vangelov@vonage.com
+ * @Last Modified time: 2019-11-05 13:46:26
+ */
+
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+    name: 'metaModel',
+    pure: true,
+    standalone: false
+})
+export class MetaModelPipe implements PipeTransform {
+  transform(value: any): any {
+    return value;
+  }
+}