@colijnit/sharedcomponents 1.0.54 → 1.0.56

package/projects/sharedcomponents/src/lib/model/tree-view-node-default.model.ts

@@ -0,0 +1,196 @@
+import {TreeViewNodeModel} from "./tree-view-node.model";
+import {TreeViewModel} from "./tree-view.model";
+import {ArrayUtils} from "../utils/array-utils";
+import {TreeViewNodeItem} from "../components/tags/component/treeview/model/tree-view-node-item";
+
+export class TreeViewNode implements TreeViewNodeModel {
+
+    public title: string;
+
+    private tree: TreeViewModel;
+
+    private id: number;
+    private level: number;
+    private children: TreeViewNodeModel[];
+    private expanded: boolean;
+    private filtered: boolean = true;
+    private showRoute: string;
+    private editRoute: string;
+
+    public constructor() {
+    }
+
+    public getId(): number {
+        return this.id;
+    }
+
+    public setId(value: number): TreeViewNodeModel {
+        this.id = value;
+        return this;
+    }
+
+    public getChildren(): TreeViewNodeModel[] {
+        return this.children;
+    }
+
+    public hasChildren(): boolean {
+        return ArrayUtils.IsArrayWithElements(this.children);
+    }
+
+    public setChildren(children: TreeViewNodeModel[]): TreeViewNodeModel {
+        this.children = children;
+        return this;
+    }
+
+    public containsChildWithGivenData(childData: any): boolean {
+        return this.children && !!(this.children as TreeViewNodeItem[]).find(child => child.data === childData);
+    }
+
+    public getSize(): number {
+        if (!this.filtered) {
+            return 0;
+        }
+        let c: number = 0;
+        this.children.forEach(child => {
+            c = c + child.getSize();
+        });
+        return c + 1;
+    }
+
+    public getLevel(): number {
+        return this.level;
+    }
+
+    public setLevel(level: number): TreeViewNodeModel {
+        this.level = level;
+        return this;
+    }
+
+    public isExpanded(): boolean {
+        return this.expanded;
+    }
+
+    public setExpanded(value: boolean): TreeViewNodeModel {
+        this.expanded = value;
+        return this;
+    }
+
+    public isFiltered(): boolean {
+        return this.filtered;
+    }
+
+    public setFiltered(value: boolean): TreeViewNodeModel {
+        this.filtered = value;
+        return this;
+    }
+
+    public getShowRoute(): string {
+        return this.showRoute;
+    }
+
+    public setShowRoute(value: string): TreeViewNodeModel {
+        this.showRoute = value;
+        return this;
+    }
+
+    public getEditRoute(): string {
+        return this.editRoute;
+    }
+
+    public setEditRoute(value: string): TreeViewNodeModel {
+        this.editRoute = value;
+        return this;
+    }
+
+    public toggle(): TreeViewNodeModel {
+        this.expanded = !this.expanded;
+        return this;
+    }
+
+    public expand(value: boolean): TreeViewNodeModel {
+        this.expanded = value;
+        this.children.forEach(child => child.expand(value));
+        return this;
+    }
+
+    public filter(term: string): TreeViewNodeModel {
+        this.filterImpl(term, false, false);
+        return this;
+    }
+
+    protected filterImpl(term: string, force: boolean = false, value: boolean): void {
+
+        // forcing a value for the node and all the children recoursively.
+        if (force) {
+            this.filtered = value;
+            this.children.forEach((child: TreeViewNode) => {
+                child.filterImpl(term, force, value);
+            });
+            return;
+        }
+
+        // looking for a proof.
+        this.filtered = this.filterCondition(term);
+
+        // matching: keeping the node and all his children.
+        if (this.filtered) {
+            this.children.forEach((child: TreeViewNode) => {
+                child.filterImpl(term, true, true);
+            });
+            return;
+        }
+
+        // not matching: keeping the node if at least one children is matching.
+        this.children.forEach((child: TreeViewNode) => {
+            child.filterImpl(term, false, false);
+            if (child.filtered) {
+                this.filtered = true;
+                return;
+            }
+        });
+    }
+
+    protected filterCondition(term: string): boolean {
+        return this.title.toLowerCase().indexOf(term) !== -1;
+    }
+
+    public getTree(): TreeViewModel {
+        return this.tree;
+    }
+
+    public setTree(tree: TreeViewModel): TreeViewNodeModel {
+        this.tree = tree;
+        return this;
+    }
+
+    public isFirst(): boolean {
+        if (this.tree) {
+            return <TreeViewNodeModel>this === this.tree.getFirst();
+        } else {
+            return false;
+        }
+    }
+
+    public isLast(): boolean {
+        if (this.tree) {
+            return <TreeViewNodeModel>this === this.tree.getLast();
+        } else {
+            return false;
+        }
+    }
+
+    public styles(): any {
+        return {
+            "padding-left": this.getLevel() * 2 + "em"
+        };
+    }
+
+    public classes(focusId: number): any {
+        return {
+            "first-item": this.isFirst(),
+            "last-item": this.isLast(),
+            "middle-item": !this.isFirst() && !this.isLast(),
+            "focus-item": focusId === this.getId()
+        };
+    }
+}

package/projects/sharedcomponents/src/lib/model/tree-view-node-item-options.model.ts

@@ -0,0 +1,12 @@
+import {Icon} from "../enum/icon.enum";
+
+export interface TreeViewNodeItemOptions {
+    idField: string;
+    parentIdField: string;
+    descriptionField: string;
+    colorField: string;
+    imgField: string;
+    iconField: string;
+    leafIcon: Icon;
+    leafConditionField: string;
+}

package/projects/sharedcomponents/src/lib/model/tree-view-node.model.ts

@@ -0,0 +1,150 @@
+import {TreeViewModel} from "./tree-view.model";
+
+export interface TreeViewNodeModel {
+
+    /**
+     * Identifier of the node.
+     * @returns {number}
+     */
+    getId(): any;
+
+    /**
+     * Set the identifier of the node.
+     * @param value
+     * @returns {TreeViewNodeModel}
+     */
+    setId(value: any): TreeViewNodeModel;
+
+    /**
+     * Children of the node.
+     * @returns {TreeViewNode[]}
+     */
+    getChildren(): TreeViewNodeModel[];
+
+    /**
+     * Set the children of the node.
+     * @returns {TreeViewNode[]}
+     */
+    setChildren(children: TreeViewNodeModel[]): TreeViewNodeModel;
+
+    /**
+     * Size of the tree with root this.
+     * @returns {number}
+     */
+    getSize(): number;
+
+    /**
+     * The hierarchical level.
+     * @returns {number}
+     */
+    getLevel(): number;
+
+    /**
+     * Set the hierarchical level.
+     * @param {number} level
+     * @returns {TreeViewNodeModel}
+     */
+    setLevel(level: number): TreeViewNodeModel;
+
+    /**
+     * If the node is currently expanded.
+     * @returns {boolean}
+     */
+    isExpanded(): boolean;
+
+    /**
+     * Set the expanded value of the node.
+     * @param {boolean} value
+     * @returns {TreeViewNodeModel}
+     */
+    setExpanded(value: boolean): TreeViewNodeModel;
+
+    /**
+     * If the node is currently filtered.
+     * @returns {boolean}
+     */
+    isFiltered(): boolean;
+
+    /**
+     * Set the filtered value of the node.
+     * @param {boolean} value
+     * @returns {TreeViewNodeModel}
+     */
+    setFiltered(value: boolean): TreeViewNodeModel;
+
+    /**
+     * Show breadCrumbs.
+     * @returns {string}
+     */
+    getShowRoute(): string;
+
+    /**
+     * Set the show breadCrumbs.
+     * @returns {string}
+     */
+    setShowRoute(value: string): TreeViewNodeModel;
+
+    /**
+     * Edit breadCrumbs.
+     * @returns {string}
+     */
+    getEditRoute(): string;
+
+    /**
+     * Set the edit breadCrumbs.
+     * @returns {string}
+     */
+    setEditRoute(value: string): TreeViewNodeModel;
+
+    /**
+     * Toggle expanded.
+     */
+    toggle(): TreeViewNodeModel;
+
+    /**
+     * Set the expand value for the tree with root this.
+     * @param value
+     */
+    expand(value: boolean): TreeViewNodeModel;
+
+    /**
+     * Set the value of the property filtered for each node of the tree with root this.
+     * @param term
+     */
+    filter(term: string): TreeViewNodeModel;
+
+    /**
+     * The tree which the node belong to.
+     * @returns {TreeViewModel}
+     */
+    getTree(): TreeViewModel;
+
+    /**
+     * Set the tree which the node belong to.
+     * @returns {TreeViewModel}
+     */
+    setTree(tree: TreeViewModel): TreeViewNodeModel;
+
+    /**
+     * First rendered node.
+     * @returns {boolean}
+     */
+    isFirst(): boolean;
+
+    /**
+     * Last rendered node.
+     * @returns {boolean}
+     */
+    isLast(): boolean;
+
+    /**
+     * Css classes.
+     */
+    classes(...args: any[]): any;
+
+    /**
+     * Css styles.
+     * @param args
+     */
+    styles(...args: any[]): any;
+}

package/projects/sharedcomponents/src/lib/model/tree-view.model.ts

@@ -0,0 +1,57 @@
+import {TreeViewNodeModel} from "./tree-view-node.model";
+
+export interface TreeViewModel {
+
+    /**
+     * Set the nodes of the tree.
+     * @param {TreeViewNodeModel[]} nodes
+     * @returns {TreeViewModel}
+     */
+    withNodes(nodes: TreeViewNodeModel[]): TreeViewModel;
+
+    /**
+     * Get the nodes of the tree.
+     * @returns {TreeViewNodeModel[]}
+     */
+    getNodes(): TreeViewNodeModel[];
+
+    /**
+     * Handler on expand tree click.
+     */
+    onExpandTree(): void;
+
+    /**
+     * Handler on collapse tree click.
+     */
+    onCollapseTree(): void;
+
+    /**
+     * Handler on filter input.
+     * @param e
+     */
+    onFilterInput(e: any): void;
+
+    /**
+     * Foreach node of the tree applies the filter method implementation.
+     * @param {string} term
+     */
+    filterTree(term: string): void;
+
+    /**
+     * The number of the node of the tree.
+     * @returns {number}
+     */
+    getSize(): number;
+
+    /**
+     * First rendered node of the tree.
+     * @returns {TreeViewNodeModel}
+     */
+    getFirst(): TreeViewNodeModel;
+
+    /**
+     * Last rendered node of the tree.
+     * @returns {TreeViewNodeModel}
+     */
+    getLast(): TreeViewNodeModel;
+}

package/projects/sharedcomponents/src/lib/model/week.model.ts

@@ -0,0 +1,5 @@
+import {Weekday} from "./weekday.model";
+
+export class Week {
+    public weekDays: Weekday[] = [];
+}

package/projects/sharedcomponents/src/lib/model/weekday.model.ts

@@ -0,0 +1,17 @@
+import {AgendaEvent} from "./agenda-event.model";
+
+export class Weekday {
+    public inView: boolean = true;
+    public weekdayDay: number;
+    public weekdayMonthShort: string;
+    public weekdayMonthLong: string;
+    public weekdayYear: number;
+    public date: Date;
+    public weekdayShort: string;
+    public weekdayLong: string;
+    public description: string;
+    public newMonth: boolean = false;
+    public weekdaySelected: boolean = false;
+    public datesByTheHour: Date[] = [];
+    public events: AgendaEvent[] = [];
+}

package/projects/sharedcomponents/src/lib/pipe/array-number.pipe.ts

@@ -0,0 +1,14 @@
+import {Pipe, PipeTransform} from "@angular/core";
+
+@Pipe({
+    name: "arrayNumber"
+})
+export class ArrayNumberPipe implements PipeTransform {
+
+    transform(length: number, offset: number = 0): number[] {
+        if (!length || length < 0) {
+            return [];
+        }
+        return Array.from({length: Math.round(length)}, (x, i) => i + offset);
+    }
+}

package/projects/sharedcomponents/src/lib/pipe/master-pipes.ts

@@ -0,0 +1,7 @@
+import {ArrayNumberPipe} from "./array-number.pipe";
+import {UCfirstPipe} from "./ucfirst.pipe";
+
+export const MASTER_PIPES: any[] = [
+  ArrayNumberPipe,
+  UCfirstPipe
+]

package/projects/sharedcomponents/src/lib/pipe/ucfirst.pipe.ts

@@ -0,0 +1,14 @@
+import {Pipe, PipeTransform} from "@angular/core";
+
+@Pipe({
+    name: "ucfirst"
+})
+// Pipe capable of transforming the first character of a string-value to upper case.
+export class UCfirstPipe implements PipeTransform {
+    transform(value: string): string {
+        if (typeof value === "string") {
+            return value.charAt(0).toUpperCase() + value.slice(1);
+        }
+        return value;
+    }
+}

package/projects/sharedcomponents/src/lib/service/dictionary.service.ts

@@ -0,0 +1,86 @@
+import {Injectable} from "@angular/core";
+import {LanguageCode} from "../enum/language-code.enum";
+import {StringUtils} from "../utils/string-utils";
+import {Dictionary} from "../assets/dictionary/text.properties";
+
+// The localization service, providing peers with text translation functionality.
+@Injectable({
+  providedIn: "root"
+})
+export class DictionaryService {
+  private readonly dictionaryUrl: string = "js/browser/res/dictionary/";
+
+  public get language(): string {
+    return this._language;
+  }
+
+  public set rootUrl(value: string) {
+    this._rootUrl = value;
+    this._dictBasePath = this._rootUrl + "/" + this.dictionaryUrl;
+  }
+
+  // public dictionaryLoaded: Subject<void> = new Subject();
+
+  private _dictBasePath: string;
+  private _rootUrl: string;
+  // private _dictionaryPromise: Map<LanguageCode, Promise<{ [key: string]: string }>> = new Map<LanguageCode, Promise<{ [key: string]: string }>>();
+  private _dictionaries: Map<string, { [key: string]: string }> = new Map<string, { [key: string]: string }>();
+  private _language: string;
+
+  // Some dictionary values have one or more '|~' texts in them, meant to be replaced with client-side given texts.
+  private readonly _placeholder: string = "|~";
+
+  constructor(
+  ) {
+  }
+
+  // Loads the dictionary for given language in memory.
+  public async setDictionary(language: string): Promise<void> {
+    this._language = language || LanguageCode.Dutch;
+    this._loadDictionary();
+  }
+
+  private _loadDictionary() {
+    if (!this._dictionaries.has(this._language)) {
+      const dictionary: Dictionary = new Dictionary();
+      // eslint-disable-next-line no-magic-numbers
+      if (dictionary.strings[this._language.substr(0, 2).toLowerCase()] !== undefined) {
+        // eslint-disable-next-line no-magic-numbers
+        this._dictionaries.set(this._language, dictionary.strings[this._language.substr(0, 2).toLowerCase()]);
+      }
+    }
+  }
+
+  /**
+   * Returns the localized text for the given dictionary key.
+   * @param {string} key
+   * @param {boolean} [upperCaseFirst = true] False for first letter lowercase, true for first letter uppercase for returned dict val
+   * @param {string[]} replacementTexts Rest params for replacement of '|~' in returned dict value
+   * @returns {string} The translated text for given dictionary key
+   */
+  public get(key: string, upperCaseFirst: boolean = true, ...replacementTexts: string[]): string {
+    if (!StringUtils.IsStringWithLength(key)) {
+      return key || "";
+    }
+
+    if (this.language === undefined) {
+      this._language = LanguageCode.Dutch;
+      this._loadDictionary();
+    }
+
+    let text: string = this._dictionaries.get(this.language)[key];
+    text = StringUtils.IsStringWithLength(text) ? text : key;
+
+    if (upperCaseFirst) {
+      text = text.charAt(0).toUpperCase() + text.slice(1);
+    } else {
+      text = text.charAt(0).toLowerCase() + text.slice(1);
+    }
+
+    if (replacementTexts.length > 0) {
+      text = StringUtils.ReplaceOccurrencesIn(text, this._placeholder, ...replacementTexts);
+    }
+
+    return text;
+  }
+}

package/projects/sharedcomponents/src/lib/service/icon-cache.service.ts

@@ -0,0 +1,51 @@
+import {Injectable} from "@angular/core";
+import {DomSanitizer, SafeHtml} from "@angular/platform-browser";
+import {Icon} from "../enum/icon.enum";
+import {IconSvg} from "../model/icon-svg";
+
+@Injectable({
+  providedIn: "root"
+})
+export class IconCacheService {
+  /**
+   * All the icons as a large JSON object, from the all-icons.json file.
+   * The object has property keys that are the icon names, and property values with the data string of the actual svg icon.
+   */
+  public get iconCache(): { [iconName: string]: SafeHtml } {
+    return this._iconCache;
+  }
+
+  private _iconCache: { [iconName: string]: SafeHtml } = {};
+
+  constructor(
+    private _sanitizer: DomSanitizer
+  ) {
+    this.setIconCache();
+  }
+
+  public getIcon(iconName: Icon | string): SafeHtml {
+    if (iconName) {
+      return this._iconCache[iconName.toLowerCase()];
+    }
+  }
+
+  public getIconAsBase64(iconName: Icon): SafeHtml {
+    const icon: string = IconSvg[iconName];
+    const base64Data: string = window.btoa(icon);
+    return this._sanitizer.bypassSecurityTrustUrl(`data:image/svg+xml;base64,${base64Data}`);
+  }
+
+  public getRawIcon(iconName: Icon): string {
+    if (iconName) {
+      return IconSvg[iconName.toLowerCase()];
+    }
+  }
+
+  public setIconCache(): void {
+    for (const key in IconSvg) {
+      if (IconSvg.hasOwnProperty(key) && typeof IconSvg[key] !== "function") {
+        this._iconCache[key.toLowerCase()] = this._sanitizer.bypassSecurityTrustHtml(IconSvg[key]);
+      }
+    }
+  }
+}

package/projects/sharedcomponents/src/lib/service/options.service.ts

@@ -0,0 +1,43 @@
+import {Injectable} from "@angular/core";
+import {BehaviorSubject} from "rxjs";
+import {DictionaryService} from "./dictionary.service";
+import {SharedSettings} from '../model/settings';
+
+@Injectable({
+  providedIn: "root"
+})
+export class OptionsService {
+
+  public optionsInitialized: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+
+  public set options(value: any) {
+    this._options = value;
+  }
+
+  public get options(): any {
+    return this._options;
+  }
+
+  public optionsLoaded: BehaviorSubject<boolean> = new BehaviorSubject(false);
+
+  private _options: any;
+
+  constructor(private _dictionary: DictionaryService) {
+  }
+
+  public async createSettingsFromObject(obj: any): Promise<void> {
+    if (!this.options) {
+      this.options = new SharedSettings();
+    }
+    this.options = Object.assign(this.options, obj);
+    this.optionsLoaded.next(true);
+  }
+
+  public async initialize(options: any): Promise<void> {
+    if (options) {
+      await this.createSettingsFromObject(options);
+      await this._dictionary.setDictionary(this.options.languageCode);
+      this.optionsInitialized.next(true);
+    }
+  }
+}