@colijnit/sharedcomponents 1.0.55 → 1.0.56

package/projects/sharedcomponents/src/lib/utils/object-utils.ts

@@ -0,0 +1,310 @@
+import {isNill} from "./is-nill.function";
+import {notNill} from "./function/not-nill.function";
+
+// Static utility function holder related to objects.
+export class ObjectUtils {
+
+    /**
+     * Returns whether all given values exist: for all values it holds that they are not null nor undefined. Short-circuit check.
+     * @param {any} values Rest parameters with all objects to check existence for.
+     * @returns {boolean} True if ALL given values are not null nor undefined, otherwise false (if at least one value was null or undefined)
+     */
+    public static AllExist(...values: any[]): boolean {
+        let allExist: boolean = true;
+        for (let i: number = 0, len: number = values.length; i < len; i++) {
+            if (isNill(values[i])) {
+                allExist = false;
+                break;
+            }
+        }
+        return allExist;
+    }
+
+    /**
+     * Copies all properties from object 'from' to object 'to'. Overwrites properties on object 'to' if property already exists.
+     * Does not copy functions, only properties.
+     * @param {Object} from The source object from which to copy all properties of to the 'to' object.
+     * @param {Object} to The object to which the properties of the 'from' object will be copied.
+     * @param {boolean} [allowUndefined = true] wether the 'to' object may be assigned null or undefined values to any of its properties.
+     */
+    public static CopyPropertiesFrom<T>(from: Object, to: T, allowUndefined: boolean = true): T {
+        if (!to) {
+            to = {} as T;
+        }
+        if (!from) {
+            return to;
+        }
+        ObjectUtils.ForOwnProperty(from, (value: any, key: string) => {
+            if (allowUndefined || notNill(value)) {
+                to[key] = value;
+            }
+        });
+        return to;
+    }
+
+    public static DeepEquals(actual: any, expected: any): boolean {
+        if (actual === expected) {
+            return true;
+        } else if (actual instanceof Date && expected instanceof Date) {
+            return actual.getTime() === expected.getTime();
+        } else if (!actual || !expected || typeof actual !== "object" && typeof expected !== "object") {
+            return actual === expected;
+        } else {
+            return this._objEquiv(actual, expected);
+        }
+    }
+
+    // Performs given callback function for each own property of given plain object. Also works on string enums.
+    public static ForOwnProperty(plainObject: any, callback: (propVal: any, key: string) => any): void {
+        if (ObjectUtils.IsPlainObject(plainObject)) {
+            for (const key in plainObject) {
+                if (plainObject.hasOwnProperty(key) && typeof plainObject[key] !== "function") {
+                    const response: boolean = callback(plainObject[key], key);
+                    if (response === false) {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    // Returns the class name of given argument. The argument can be an object or a class.
+    public static GetClassName(objectOrClass: any): string {
+        if (!objectOrClass) {
+            return undefined;
+            // arg was a class (or a function..)
+        } else if (objectOrClass.constructor === Function) {
+            return objectOrClass.name; // .. which has its readable name stores like this
+            // else arg was an object
+        } else {
+            const constructorString: string = objectOrClass.constructor.toString();
+            return constructorString.match(/\w+/g)[1];
+        }
+    }
+
+    // Returns a shallow clone of the given original object. The clone is a SIMPLE OBJECT with the same properties as the original.
+    public static GetShallowClone(originalObject: any, objectClass?: any): any {
+        let clonedObject: any = undefined;
+
+        if (objectClass) {
+            clonedObject = new objectClass();
+        } else {
+            clonedObject = {};
+        }
+
+        ObjectUtils.ForOwnProperty(originalObject, (value: any, key: string) => {
+            clonedObject[key] = value;
+        });
+
+        return clonedObject;
+    }
+
+    public static GetDeepClone(originalObject: any, circular: boolean = true): any {
+        // First create an empty object with
+        // same prototype of our original source
+
+        let propertyIndex: number;
+        let descriptor: PropertyDescriptor;
+        let keys: string[];
+        let current: any;
+        let nextSource: any;
+        let indexOf: number;
+        const copies: any[] = [{
+            source: originalObject,
+            target: Object.create(Object.getPrototypeOf(originalObject))
+        }];
+        const cloneObject: any = copies[0].target;
+        const sourceReferences: any[] = [originalObject];
+        const targetReferences: any[] = [cloneObject];
+
+        // First in, first out
+        while (current = copies.shift()) { //NOSONAR
+            keys = Object.getOwnPropertyNames(current.source);
+
+            for (propertyIndex = 0; propertyIndex < keys.length; propertyIndex++) {
+                // Save the source's descriptor
+                descriptor = Object.getOwnPropertyDescriptor(current.source, keys[propertyIndex]);
+
+                if (!descriptor.value || typeof descriptor.value !== "object") {
+                    Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                    continue;
+                }
+
+                nextSource = descriptor.value;
+                descriptor.value = Array.isArray(nextSource) ?
+                    [] :
+                    Object.create(Object.getPrototypeOf(nextSource));
+
+                if (circular) {
+                    indexOf = sourceReferences.indexOf(nextSource);
+
+                    if (indexOf !== -1) {
+                        // The source is already referenced, just assign reference
+                        descriptor.value = targetReferences[indexOf];
+                        Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+                        continue;
+                    }
+
+                    sourceReferences.push(nextSource);
+                    targetReferences.push(descriptor.value);
+                }
+
+                Object.defineProperty(current.target, keys[propertyIndex], descriptor);
+
+                copies.push({source: nextSource, target: descriptor.value});
+            }
+        }
+
+        return cloneObject;
+    }
+
+    public static IsEmpty(obj: any): boolean {
+        return isNill(obj) || Object.getOwnPropertyNames(obj).length === 0;
+    }
+
+    // Returns whether given object is an existing, plain object. That is, it defined, its type if 'object' and it is NOT an array or func.
+    public static IsPlainObject(object: any): boolean {
+        return object !== null && !Array.isArray(object) && typeof object !== "function" && typeof object === "object";
+    }
+
+    /**
+     * Returns an instance of given class with data of given dataObject. Only works if that class has a default constructor without args.
+     * Does not actually create a new object if it alread is an instance of that class.
+     * @param {any} clazz A class that has a default constructor
+     * @param {any} [dataObject] The object with data to copy to the new instance of the class
+     * @returns {any} An object that is an instance of given class, with given data applied to it.
+     */
+    public static MakeInstanceOf(clazz: any, dataObject?: any): any {
+        // dont make a clone if given dataObject already instance of clazz
+        if (dataObject instanceof clazz) {
+            return dataObject;
+        } else {
+            const asClazz: any = new clazz();
+            ObjectUtils.CopyPropertiesFrom(dataObject, asClazz);
+            return asClazz;
+        }
+    }
+
+    // Returns the value of a random own property of given object.
+    public static PickRandomPropertyValue(object: any): any {
+        if (!object) {
+            return;
+        }
+
+        let result: any;
+        let count: number = 0;
+        for (const prop in object) {
+            if (object.hasOwnProperty(prop)) {
+                count++;
+                if (Math.random() < 1 / count) {
+                    result = object[prop];
+                }
+            }
+        }
+        return result;
+    }
+
+    // Returns a default if given value doesn't exist, otherwise just value.
+    public static ValueOrDefault(value: any, defaultReturnVal: any = ""): any {
+        return notNill(value) ? value : defaultReturnVal;
+    }
+
+    private static _isArguments(x: any): boolean {
+        const supportsArgsClass: boolean = this._supportsArgumentsClass();
+        return supportsArgsClass ? this._isArgumentsWhenArgsClassSupported(x) : this._isArgumentsWhenArgsClassNotSupported(x);
+    }
+
+    private static _isArgumentsWhenArgsClassNotSupported(object: any): boolean {
+        return object &&
+            typeof object === "object" &&
+            typeof object.length === "number" &&
+            Object.prototype.hasOwnProperty.call(object, "callee") &&
+            !Object.prototype.propertyIsEnumerable.call(object, "callee") ||
+            false;
+    }
+
+    private static _isArgumentsWhenArgsClassSupported(object: any): boolean {
+        return Object.prototype.toString.call(object) === "[object Arguments]";
+    }
+
+    private static _isBuffer(x: any): boolean {
+        if (!x || typeof x !== "object" || typeof x.length !== "number") {
+            return false;
+        }
+        if (typeof x.copy !== "function" || typeof x.slice !== "function") {
+            return false;
+        }
+        return !(x.length > 0 && typeof x[0] !== "number");
+    }
+
+    private static _isUndefinedOrNull(value: any): boolean {
+        return value === null || value === undefined;
+    }
+
+    private static _objEquiv(a: any, b: any): boolean {
+        let i: number, key: string;
+        if (this._isUndefinedOrNull(a) || this._isUndefinedOrNull(b)) {
+            return false;
+        }
+
+        if (a.prototype !== b.prototype) {
+            return false;
+        }
+
+        if (this._isArguments(a)) {
+            if (!this._isArguments(b)) {
+                return false;
+            }
+            a = Array.prototype.slice.call(a);
+            b = Array.prototype.slice.call(b);
+            return this.DeepEquals(a, b);
+        }
+        if (this._isBuffer(a)) {
+            if (!this._isBuffer(b)) {
+                return false;
+            }
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (i = 0; i < a.length; i++) {
+                if (a[i] !== b[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        let ka: string[];
+        let kb: string[];
+        try {
+            ka = Object.keys(a);
+            kb = Object.keys(b);
+        } catch (e) {
+            return false;
+        }
+
+        if (ka.length !== kb.length) {
+            return false;
+        }
+
+        ka.sort();
+        kb.sort();
+
+        for (i = ka.length - 1; i >= 0; i--) {
+            if (ka[i] !== kb[i]) {
+                return false;
+            }
+        }
+
+        for (i = ka.length - 1; i >= 0; i--) {
+            key = ka[i];
+            if (!this.DeepEquals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return typeof a === typeof b;
+    }
+
+    private static _supportsArgumentsClass(): boolean {
+        return Object.prototype.toString.call(arguments) === "[object Arguments]";
+    }
+}

package/projects/sharedcomponents/src/lib/utils/string-utils.ts

@@ -0,0 +1,67 @@
+// Static utility functions holder related to strings.
+export class StringUtils {
+
+  /**
+   * Returns a new string where given placeholder in given source string are replaced by given replacement texts.
+   *
+   * Example usage:
+   *
+   * source = "ABCDABCD"
+   * placeholder = "BC"
+   * replacementTexts = "Z", "Z" (REST arguments)
+   * OUTPUT = "AZDAZD"
+   *
+   * @param {string} source
+   * @param {string} placeholder
+   * @param {string} replacementTexts If only one is given, this function replaces all placeholders with that single replacementText.
+   * If more are given, placeholders without a corresponding replacementText will remain their original placeholder characters.
+   */
+  public static ReplaceOccurrencesIn(source: string, placeholder: string, ...replacementTexts: string[]): string {
+    // parameter guards
+    if (!(source)) {
+      return undefined;
+    }
+    if (!placeholder || replacementTexts.length === 0) {
+      return source;
+    }
+    let outString: string = source;
+    // one replacementText means replace for all
+    if (replacementTexts.length === 1) {
+      // "g" is the g flag to replace globally
+      outString = outString.replace(placeholder, replacementTexts[0]);
+    } else {
+      // replace occurence i by replacementTexts[i], one at a time in loop (there might be a faster way..)
+      for (let i: number = 0, len: number = replacementTexts.length; i < len; i++) {
+        outString = outString.replace(placeholder, replacementTexts[i]);
+      }
+    }
+    return outString;
+  }
+
+  // Returns the given argument as a string. Returns given defaultValue if conversion of argument to string was impossible.
+  public static ParseString(arg: any, defaultValue: string = ""): string {
+    if (!StringUtils.IsString(arg)) {
+      if (arg && typeof arg.toString === "function") {
+        arg = arg.toString();
+      } else {
+        arg = defaultValue;
+      }
+    }
+    return arg;
+  }
+
+  public static IsString(str: any): boolean {
+    return typeof str === 'string';
+  }
+
+  // Returns whether given str is a string and has a length > 0.
+  public static IsStringWithLength(str: string): boolean {
+    return str && StringUtils.IsString(str) && str.length > 0;
+  }
+
+  // Returns given string, escaped for use as string literal in regular expressions.
+  private static _escapeRegExp(str: string): string {
+    return str;// .replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^$\|]/g, "\\$&");
+  }
+
+}

package/projects/sharedcomponents/src/lib/utils/tree-utils.ts

@@ -0,0 +1,63 @@
+import {TreeViewNodeItem} from "../components/tags/component/treeview/model/tree-view-node-item";
+import {TreeViewNodeItemOptions} from "../model/tree-view-node-item-options.model";
+import {TreeObject} from "../model/tree-object";
+import {isNill} from "./is-nill.function";
+import {notNill} from "./function/not-nill.function";
+import {Icon} from "../enum/icon.enum";
+
+export class TreeUtils {
+
+    public static convertToTreeViewItems(data: TreeObject[], options: TreeViewNodeItemOptions): TreeViewNodeItem[] {
+        const items: TreeViewNodeItem[] = [];
+
+          data.filter(bo => bo[options.parentIdField] == null).forEach(bo => {
+            const root: TreeViewNodeItem = TreeUtils.buildTreeViewNodeItem(data, bo, options);
+            root.setId(data.indexOf(bo));
+            root.setChildren(data.filter(node => node[options.parentIdField] === bo[options.idField]).map(node => TreeUtils.buildTreeViewNodeItem(data, node, options)));
+            items.push(root);
+          });
+
+        return items;
+    }
+
+    private static buildTreeViewNodeItem(source: TreeObject[], data: TreeObject, options: TreeViewNodeItemOptions): TreeViewNodeItem {
+        const dataIndex: number = source.indexOf(data);
+        data.nodeOpen = (source[dataIndex + 1] !== undefined) ? source[dataIndex + 1].parentNodeOpen : false;
+
+        const node: TreeViewNodeItem = new TreeViewNodeItem();
+        node.setData(data);
+        node.setFiltered(true);
+        node.setLevel(data.treeLevel);
+        node.setExpanded(data.nodeOpen);
+        node.setId(dataIndex);
+        node.setCode(data[options.idField]);
+        node.setDescription(data[options.descriptionField]);
+        node.title = data[options.descriptionField];
+
+        if (notNill(options.imgField)) {
+            node.setImg(data[options.imgField]);
+        }
+
+        if (notNill(options.colorField)) {
+            node.setCustomColor(data[options.colorField]);
+        }
+
+        if (notNill(options.iconField) && notNill(data[options.iconField])) {
+            node.setIcon(<Icon> data[options.iconField]);
+        } else if (notNill(options.leafIcon) && !data.hasChildren && TreeUtils.leafConditionMet(data, options.leafConditionField)) {
+            node.setIcon(options.leafIcon);
+        }
+
+        node.setChildren(source.filter(child => child[options.parentIdField] === data[options.idField]).map(child => TreeUtils.buildTreeViewNodeItem(source, child, options)));
+        return node;
+    }
+
+    public static leafConditionMet(data: TreeObject, leafCondition: string): boolean {
+        if (notNill(leafCondition)) {
+            if (isNill(data[leafCondition]) || (typeof data[leafCondition] === "boolean" && data[leafCondition] === false)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

package/{public-api.d.ts → projects/sharedcomponents/src/public-api.ts}

@@ -1,3 +1,7 @@
+/*
+ * Public API Surface of sharedcomponents
+ */
+
 export * from './lib/components/docsign/docsign.component';
 export * from './lib/components/docsign/docsign.module';
 export * from './lib/components/stock/stock.component';
@@ -18,3 +22,6 @@ export * from './lib/components/date-planning/date-planning.module';
 export * from './lib/components/simple-tags/simple-tags.component';
 export * from './lib/components/simple-tags/simple-tags.module';
 export * from './lib/service/shared.service';
+export * from './lib/enum/calendar-view.enum';
+export * from './lib/model/agenda-event-per-day.model';
+export * from './lib/model/agenda-event.model';

package/projects/sharedcomponents/src/test.ts

@@ -0,0 +1,27 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    <T>(id: string): T;
+    keys(): string[];
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting(),
+);
+
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/projects/sharedcomponents/tsconfig.lib.json

@@ -0,0 +1,18 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": []
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ],
+  "types": [
+    "src/lib/@types"
+  ]
+}

package/projects/sharedcomponents/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/projects/sharedcomponents/tsconfig.spec.json

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/script/create-bundle-version.js

@@ -0,0 +1,19 @@
+let fs = require('fs-extra');
+let argv = require('minimist')(process.argv.slice(2));
+
+const destDir = 'src/app/bundle';
+const versionFile = 'shared-version.ts';
+const packageFile = 'package.json';
+
+let packageFileData = fs.readFileSync(packageFile, {encoding: 'utf8'});
+const json = JSON.parse(packageFileData);
+
+const template = `// this file is dynamically created, do not change this
+export class Version {
+  public name = "${json.name}";
+  public description = "${json.description}";
+  public symVer = "${json.version}";
+  public publishDate = "${new Date().toLocaleString()}";
+}`;
+
+fs.writeFileSync(destDir + '/' + versionFile, template, 'utf8');

package/script/merge-icons.js

@@ -0,0 +1,39 @@
+const fs = require('fs');
+const icons = {};
+const srcDir = 'projects/sharedcomponents/src/lib/assets/icons/';
+const dataFile = 'projects/sharedcomponents/src/lib/model/icon-svg.ts';
+const enumFile = 'projects/sharedcomponents/src/lib/enum/icon.enum.ts';
+const warning = '/** AUTO GENERATED FILE. DO NOT CHANGE.. OR YOU WILL SUFFER THE CONSEQUENCES OF YOUR ACTIONS **/';
+
+
+function minifyXml(xml) {
+    return xml
+        .replace(/(<\?xml.*\?>)|(<!--.*-->)|(\n)|(\t)|(\r)|(xmlns:.*?".*?"\s?)|(id=".*?"\s?)|(data-name=".*?"\s?)|(xml:space=".*?"\s?)/gim, '')
+        .replace(/\s{2,}/g, ' ')
+        .replace(/> </g, '><');
+}
+
+function toPascalCase(icon) {
+    return icon.charAt(0).toUpperCase() + icon.slice(1).replace(/(_[a-z]?)/gi, (match) => {
+        return match.toUpperCase().replace(/_/g, '');
+    });
+}
+
+fs.readdirSync(srcDir)
+    .filter(file => file.substr(-4).toLowerCase() === '.svg')
+    .reduce((icons, file) => {
+        icons[file.substr(0, file.length - 4)] = minifyXml(fs.readFileSync(srcDir + file, {encoding : 'utf-8'}));
+        return icons;
+    }, icons);
+
+fs.writeFileSync(dataFile, `${warning}
+
+export const IconSvg: {[iconName: string]: string} =  ${JSON.stringify(icons, null, 1)};`
+);
+
+fs.writeFileSync(enumFile, `${warning}
+
+export enum Icon {
+    ${Object.keys(icons).map(icon => toPascalCase(icon) + ' = "' + icon + '"').join(",\n    ")}
+}`
+);

package/src/app/app.component.scss

@@ -0,0 +1,31 @@
+.full-size-scroll {
+  height: 100%;
+  width: 100%;
+  overflow: scroll;
+  padding: 20px;
+}
+
+.key-pad-resize-wrapper {
+  padding: 20px;
+  background-color: #00dc00;
+  width: 250px;
+}
+
+.custom-width {
+  width: 400px;
+}
+
+.statusbar-wrapper {
+  display: flex;
+  flex-direction: column;
+  height: 150px;
+  overflow: auto;
+}
+
+.test {
+  min-height: 80px;
+}
+
+.button-list {
+  margin: 10px;
+}

package/src/app/app.component.spec.ts

@@ -0,0 +1,31 @@
+import { TestBed } from '@angular/core/testing';
+import { AppComponent } from './app.component';
+
+describe('AppComponent', () => {
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+      declarations: [
+        AppComponent
+      ],
+    }).compileComponents();
+  });
+
+  it('should create the app', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    expect(app).toBeTruthy();
+  });
+
+  it(`should have as title 'Sharedcomponents'`, () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    const app = fixture.componentInstance;
+    expect(app.title).toEqual('Sharedcomponents');
+  });
+
+  it('should render title', () => {
+    const fixture = TestBed.createComponent(AppComponent);
+    fixture.detectChanges();
+    const compiled = fixture.nativeElement as HTMLElement;
+    expect(compiled.querySelector('.content span')?.textContent).toContain('Sharedcomponents app is running!');
+  });
+});