@mosa-ng/core 17.0.0

package/src/lib/utils/prototypes.util.ts

@@ -0,0 +1,167 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+/**
+ * Cast any type
+ * @param data to be casted
+ * @returns casted data
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any,max-classes-per-file
+export function cast<T>(data: any): T {
+    return data as T;
+}
+
+export class StringExtensions implements IStringExtensions {
+    public getPart(maxChars: number, appendDot?: boolean): string {
+        let newStr = cast<string>(this).replace(/\\n/g, ' ');
+        if (newStr.length > maxChars) {
+            newStr = newStr.substring(0, maxChars);
+            if (appendDot && newStr.length > maxChars - 3) {
+                newStr += '...';
+            }
+        }
+        return newStr;
+    }
+
+    public fromJSON<T>(): T {
+        let str: string = cast<string>(this);
+        if (typeof this !== 'string') {
+            str = JSON.stringify(str);
+        }
+
+        try {
+            str = JSON.parse(str);
+        } catch (e) {
+            return null;
+        }
+
+        if (typeof str === 'object') {
+            return str as T;
+        }
+
+        return null;
+    }
+
+    public toCSSClass(): string {
+        return cast<string>(this)?.replace(/([a-z])([A-Z])/, '$1-$2').toLowerCase();
+    }
+
+    public toUTC(): string {
+        return `${cast<string>(this)}Z`;
+    }
+}
+
+export class ArrayExtensions implements IArrayExtensions {
+    public hasChanges<T>(data: T[]): boolean {
+        return JSON.stringify(this) !== JSON.stringify(data);
+    }
+
+    public replaceRange<T>(data: T[], start: number, end: number): T[] {
+        const array: T[] = cast<T[]>(this);
+        let replaceDataIndex: number = 0;
+        for (let i: number = start; i < end; i++) {
+            if (!array[ i ] && !data[ replaceDataIndex ]) {
+                array.splice(i, 1);
+                continue;
+            }
+
+            array[ i ] = data[ replaceDataIndex ];
+            replaceDataIndex++;
+        }
+        return array;
+    }
+}
+
+export class NumberExtensions implements INumberExtensions {
+    public between(start: number, end: number): boolean {
+        const num: number = cast<number>(this);
+        return num >= start && num <= end;
+    }
+}
+
+/**
+ * @interface StringExtensions
+ */
+export interface IStringExtensions {
+    /**
+     * Gets a part of a string
+     * @param maxChars maximum amount of chars
+     * @param appendDot append three dots at the end
+     * @returns splitted string
+     */
+    getPart(maxChars: number, appendDot?: boolean): string;
+
+    /**
+     * Converts a string from json
+     * @returns object of expected type
+     */
+    fromJSON<T>(): T;
+
+    /**
+     * Converts a string to a css class
+     * @returns converted kebab case css class
+     */
+    toCSSClass(): string;
+
+    /**
+     * Converts a datetime string to utc format
+     */
+    toUTC(): string;
+}
+
+export interface IArrayExtensions {
+    /**
+     * Checks if array has changes
+     * @param data array passed
+     * @deprecated learn how to program
+     */
+    hasChanges: <T>(data: T[]) => boolean;
+    /**
+     * Replaces a specific element range in an array
+     * @param data
+     */
+    replaceRange: <T>(replaceData: T[], start: number, end: number) => T[];
+}
+
+export interface INumberExtensions {
+    /**
+     * checks if a number in a range
+     * @param start of range
+     * @param end of range
+     */
+    between(start: number, end: number): boolean;
+}
+
+declare global {
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface,id-blacklist
+    interface String extends IStringExtensions {
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface,@typescript-eslint/no-unused-vars
+    interface Array<T> extends IArrayExtensions {
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-empty-interface,id-blacklist
+    interface Number extends INumberExtensions {
+    }
+}
+
+export class Prototypes {
+
+    /**
+     * Initialize prototypes
+     */
+    public static init(): void {
+        const stringExtensions = new StringExtensions();
+        const arrayExtensions = new ArrayExtensions();
+        const numberExtensions = new NumberExtensions();
+
+        String.prototype.getPart = stringExtensions.getPart;
+        String.prototype.fromJSON = stringExtensions.fromJSON;
+        String.prototype.toCSSClass = stringExtensions.toCSSClass;
+        String.prototype.toUTC = stringExtensions.toUTC;
+
+        Array.prototype.hasChanges = arrayExtensions.hasChanges;
+        Array.prototype.replaceRange = arrayExtensions.replaceRange;
+
+        Number.prototype.between = numberExtensions.between;
+    }
+}

package/src/lib/utils/sieve.util.ts

@@ -0,0 +1,169 @@
+import { ISieveFilter } from '../models/sieve/sieve-filter.model';
+import { SieveOperator } from '../models/sieve/sieve-operator.model';
+import { ISieveOptions } from '../models/sieve/sieve-options.model';
+import { ISieveSort } from '../models/sieve/sieve-sort.model';
+
+export class Sieve {
+
+    private readonly options: ISieveOptions;
+
+    constructor(options: ISieveOptions) {
+        this.options = options;
+        this.options.baseUrl = options.baseUrl || '';
+        this.options.filters = options.filters || [];
+        this.options.sorts = options.sorts || [];
+    }
+
+    /**
+     * public getter to get page size
+     */
+    public get pageSize(): number {
+        return this.options.pageSize;
+    }
+
+    /**
+     * Setter to set page size
+     */
+    public set pageSize(pageSize: number) {
+        this.options.pageSize = pageSize;
+    }
+
+    /**
+     * public getter to get page
+     */
+    public get page(): number {
+        return this.options.page;
+    }
+
+    /**
+     * Setter to set page
+     */
+    public set page(page: number) {
+        this.options.page = page;
+    }
+
+    /**
+     * public getter to get filters
+     */
+    public get filters(): ISieveFilter[] {
+        return this.options.filters;
+    }
+
+    /**
+     * Setter to set filters
+     */
+    public set filters(filters: ISieveFilter[]) {
+        this.options.filters = filters;
+    }
+
+    /**
+     * public getter to get sorts
+     */
+    public get sorts(): ISieveSort[] {
+        return this.options.sorts;
+    }
+
+    /**
+     * Setter to set sorts
+     */
+    public set sorts(sorts: ISieveSort[]) {
+        this.options.sorts = sorts;
+    }
+
+    /**
+     * method to add a sort option
+     * @param name of the item to sort
+     * @param desc sort descending
+     */
+    public addSort(name: string, desc?: boolean): void {
+        this.options.sorts.push({
+            name,
+            desc,
+        });
+    }
+
+    /**
+     * method to add a filter option
+     * @param key of the item
+     * @param operator { SieveOperator }
+     * @param value filtered value
+     */
+    public addFilter(key: string, operator: SieveOperator, value: string): void {
+        this.options.filters.push({
+            key,
+            operator,
+            value,
+        });
+    }
+
+    /**
+     * Getter for base url
+     */
+    public get baseUrl(): string {
+        return this.options.baseUrl;
+    }
+
+    /**
+     * Setter for base url
+     * @param url
+     */
+    public set baseUrl(url: string) {
+        this.options.baseUrl = url;
+    }
+
+    /**
+     * Convert to queried string
+     */
+    public getUrl(): string {
+        return `${ this.options.baseUrl }${ this.toQuery() }`;
+    }
+
+    /**
+     * to Query
+     * @private converts options to actual query
+     */
+    private toQuery(): string {
+        let query = '?';
+
+        if (this.page) {
+            query += `page=${ this.page }`;
+        }
+
+        if (this.pageSize) {
+            query += `&pageSize=${ this.pageSize }`;
+        }
+
+        if (this.filters?.length) {
+            let filterQuery: string = '&filters=';
+
+            for (const filter of this.filters) {
+                if (filter.value) {
+                    filterQuery += `${ filter.key }${ filter.operator }${ filter.value },`;
+                }
+            }
+
+            if (filterQuery !== '&filters=') {
+                filterQuery = filterQuery.slice(0, -1);
+                query += filterQuery;
+            }
+        }
+
+        if (this.sorts?.length) {
+            let sortQuery: string = '&sorts=';
+
+            for (const sort of this.sorts) {
+                sortQuery += `${ sort.desc ? '-' : '+' }${ sort.name },`;
+            }
+
+            sortQuery = sortQuery.slice(0, -1);
+            query += sortQuery;
+        }
+
+        if (query.startsWith('&')) {
+            query = query.slice(1);
+        }
+
+        return query;
+    }
+
+}

package/src/lib/utils/size.util.ts

@@ -0,0 +1,4 @@
+export interface ISize {
+    width: number;
+    height: number;
+}

package/src/public-api.ts

@@ -0,0 +1 @@
+export * from './lib/mosa-core.module';

package/tsconfig.lib.json

@@ -0,0 +1,16 @@
+/* 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": [
+            "node",
+        ]
+    },
+    "exclude": [
+        "**/*.spec.ts"
+    ]
+}

package/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/tsconfig.spec.json

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