right-angled
Version:
Lightweight and easy to use angular data grids. Integrates with your markup and styles rather than generating its own.
261 lines • 39.4 kB
JavaScript
import { Injectable } from '@angular/core';
import { cloneAsLiteral, coerceValue } from '../utilities';
import { BehaviorSubject, Subject } from 'rxjs';
import * as i0 from "@angular/core";
/**
* Used for declarative building of objects which represent valuable state of `target object`.
*
* Since this declaration is pretty abstract and hard to understand, let's look at a specific sample.
*
* Typical usage of this service is something like this:
* ```JavaScript
* class EndUserClass {
* @filter
* public parameter1 = 'Hey';
* @filter
* public parameter2 = 'There';
* }
* let endUserClassInstance = new EndUserClass();
* let filterService = new FilterService(endUserClassInstance);
* ```
* Now we can use created `filtersService` instance for several cases:
* - by calling {@link getRequestState} we can get serializable representation of object state
* ```JavaScript
* {
* parameter1: 'Hey',
* parameter2: 'There'
* }
* ```
* - by calling {@link resetValues} we can reset values of annotated properties to initial values (or to what was specified in {@link FilterConfig.defaultValue} property).
* - by calling {@link applyParams} we can automatically apply any set of values to annotated properties (we can pass queryString object to automatically apply values from it, for example).
* - by calling {@link getRequestState} with some filters we can "query" the state of filters and save it to the settings storage, for example.
* - by calling {@link registerFilterTarget} you can add any count of additional objects and get their
* composed state via {@link getRequestState} method as well as process them all with {@link resetValues} and {@link applyParams}.
*/
export class RTFiltersService {
constructor() {
/**
* Collection of {@link FilterConfig} settings that matches configuration for all objects that were registered in current service instance via {@link registerFilterTarget} method.
*
* This collection is also filled up with configurations of passed `target objects` base classes since config applicability is determined by `instanceof` check.
*
* This collection is "lazy" and will be filled up on first call of {@link resetValues}, {@link applyParams} or {@link getRequestState} method.
*/
this.appliedFiltersMap = new Map();
}
/**
* Global collection of all filters configuration.
*
* Used to build {@link appliedFiltersMap} for concrete set of objects that were registered as `target objects` via {@link registerFilterTarget} for concrete service instance.
*/
static { this.filterPropertiesMap = new Map(); }
/**
* @param target `target object` that will be registered with {@link registerFilterTarget} method.
*/
/**
* Used to register type property as `target property` with specified filter config for later usage with {@link FiltersService}.
*
* This method is called by {@link filter} annotation, for example.
* @param targetType type definition that contains specified property declaration.
* @param propertyConfig configuration for property as a filter.
*/
static registerFilterConfig(targetType, propertyConfig) {
const typeConfigs = RTFiltersService.filterPropertiesMap.has(targetType)
? RTFiltersService.filterPropertiesMap.get(targetType)
: new Array();
typeConfigs.push(propertyConfig);
RTFiltersService.filterPropertiesMap.set(targetType, typeConfigs);
}
/**
* Used to build resulted value of `target property` based on specified {@link FilterConfig}.
*
* This method is used by {@link getRequestState} and also calls oneself for the case of array values.
*
*
* In addition to {@link FilterConfig} configuration, this method checks if `target property` has method `toRequest()`. If so this method will be used to get serialized value.
*
* This convention has sense in several scenarios:
* - Serialization of complex object can be performed by it's own method which was declared once instead of copy-paste it in {@link FilterConfig.serializeFormatter} declarations.
* - Very tricky but sometimes useful usage of this convention is to declare `toRequest` in `Date` prototype.
*
* This gives ability to easily send `Date` objects to the server in appropriate format which server can apply or, for example, always send UTC-dates.
*
* But be accurate with this approach. There's a lot of problems with extending of embedded types.
*
* @param target `target` object which holds specified `target property`. Used as `this` scope for {@link FilterConfig.serializeFormatter} method.
* @param value raw value of `target` property.
* @param config filter configuration for `target` property.
*/
static buildFilterValue(target, value, config) {
let result = value;
if (config && config.serializeFormatter) {
return config.serializeFormatter.call(target, result);
}
result = config && config.emptyIsNull ? result || null : result;
result = config && config.coerce ? coerceValue(result) : result;
if (result && result.toRequest) {
return result.toRequest();
}
if (Array.isArray(result)) {
const temp = [];
for (let i = 0; i < result.length; i++) {
temp[i] = RTFiltersService.buildFilterValue(target, result[i], null);
}
return temp;
}
return result;
}
/**
* Performs service destroy.
*/
destroy() {
this.appliedFiltersMap.clear();
}
/**
* Goes through all `target properties` of all `target objects` and sets their values to configured default.
*
* Default value will be determined as:
* - If value for {@link FilterConfig.defaultValue} is specified it will be applied.
* - Otherwise this service writes to {@link FilterConfig.defaultValue} value of `target property` at the moment of first call of
* {@link resetValues}, {@link applyParams} or {@link getRequestState}.
*
* This method performs next actions:
* - If value specified as {@link FilterConfig.defaultValue} is function it will be called with `target object` as `this` scope. If specified value is not a function it will be used by itself.
* - Result of previous step will be cloned by {@link cloneLiteral} function to avoid possible reference types problems.
* - If {@link FilterConfig.parseFormatter} method is specified it will be called with previous step result as parameter.
* - Result of previous steps is applied as value to `target property`.
*/
resetValues() {
this.appliedFiltersMap.forEach((targetConfig, target) => {
for (const config of targetConfig) {
const defaultValue = typeof config.defaultValue === 'function' ? config.defaultValue.call(target) : config.defaultValue;
const clonedObject = cloneAsLiteral({ defaultValue });
this.setPropertyValue(target, config, config.parseFormatter ? config.parseFormatter.call(target, clonedObject.defaultValue) : clonedObject.defaultValue);
}
});
}
/**
* Goes through all `target properties` of all `target objects` and tries to find property within passed object which name is equal
* to configured {@link FilterConfig.parameterName}.
*
* If match is found, value of the property from passed object is applied to `target property` in accordance with
* {@link FilterConfig.ignoreOnAutoMap}, {@link FilterConfig.emptyIsNull}, {@link FilterConfig.coerce}, {@link FilterConfig.parseFormatter}.
* @param params - object with values to apply.
*/
applyParams(params) {
this.appliedFiltersMap.forEach((targetConfig, target) => {
for (const config of targetConfig) {
if (params && Object.prototype.hasOwnProperty.call(params, config.parameterName) && false === config.ignoreOnAutoMap) {
let proposedVal = config.emptyIsNull ? params[config.parameterName] || null : params[config.parameterName];
proposedVal = config.coerce ? coerceValue(proposedVal) : proposedVal;
this.setPropertyValue(target, config, config.parseFormatter ? config.parseFormatter.call(target, proposedVal, params) : proposedVal);
}
}
});
}
/**
* Goes through all `target properties` of all `target objects` and applies their values to one resulted object literal.
*
* Typical usage of this method is building request to send it to the server.
*
* Names of properties in result object depends on {@link FilterConfig.parameterName}. Final values would be constructed by {@link buildFilterValue} method.
* @param filterFn - optional function to filter applied values.
* @returns resulted object literal.
*/
getRequestState(filterFn) {
const result = {};
this.appliedFiltersMap.forEach((targetConfig, target) => {
for (let config of targetConfig) {
config = { ...config };
const proposedVal = this.getPropertyValue(target, config);
if (filterFn ? filterFn(config, proposedVal, target) : true) {
const resultValue = RTFiltersService.buildFilterValue(target, proposedVal, config);
if (!config.omitIfNullOrUndefined || (resultValue !== null && typeof resultValue !== 'undefined')) {
result[config.parameterName] = resultValue;
}
}
}
});
return result;
}
/**
* Registers passed object as `target object` for current service instance.
*
* {@link getRequestState} method will compose result from objects that were registered by this method.
*
* {@link applyParams} and {@link resetValues} methods processes registered objects that were registered by this method.
* @param targets object(s) to register as `target object`.
*/
registerFilterTarget(...targets) {
targets.forEach((target) => {
if (target === null || target === undefined) {
return;
}
this.appliedFiltersMap.set(target, null);
this.buildFilterTargetMap(target);
});
}
/**
* Removes passed object from `target objects` collection for current service instance.
*
* This means that {@link getRequestState}, {@link applyParams} and {@link resetValues} methods stops to process this objects.
* @param targets object(s) to remove from collection of `target object`.
*/
removeFilterTarget(...targets) {
targets.forEach((target) => {
this.appliedFiltersMap.delete(target);
});
}
/**
* Builds map of settings for passed `target` object.
*/
buildFilterTargetMap(target) {
let targetConfig = new Array();
RTFiltersService.filterPropertiesMap.forEach((typeConfig, type) => {
if (target instanceof type) {
targetConfig = targetConfig.concat(typeConfig);
for (const config of targetConfig) {
if (typeof config.defaultValue === 'undefined') {
config.defaultValue = cloneAsLiteral({
defaultValue: this.getPropertyValue(target, config)
}).defaultValue;
}
}
}
});
if (targetConfig.length > 0) {
this.appliedFiltersMap.set(target, targetConfig);
}
else {
this.appliedFiltersMap.delete(target);
}
}
getPropertyValue(target, config) {
if (target[config.propertyName] instanceof BehaviorSubject) {
return target[config.propertyName].getValue();
}
// duck type reactive form control
if (!!target[config.propertyName] && !!target[config.propertyName].setValue && !!target[config.propertyName].status) {
return target[config.propertyName].value;
}
return target[config.propertyName];
}
setPropertyValue(target, config, value) {
if (!!target[config.propertyName] && target[config.propertyName] instanceof Subject) {
target[config.propertyName].next(value);
return;
}
// duck type reactive form control
if (!!target[config.propertyName] && target[config.propertyName].setValue) {
target[config.propertyName].setValue(value);
return;
}
target[config.propertyName] = value;
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTFiltersService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTFiltersService }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: RTFiltersService, decorators: [{
type: Injectable
}] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filters.service.js","sourceRoot":"","sources":["../../../../../projects/right-angled/src/lib/filters/filters.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { FilterConfig } from '../core/filter-config';\r\nimport { cloneAsLiteral, coerceValue } from '../utilities';\r\nimport { BehaviorSubject, Subject } from 'rxjs';\r\n/**\r\n * Used for declarative building of objects which represent valuable state of `target object`.\r\n *\r\n * Since this declaration is pretty abstract and hard to understand, let's look at a specific sample.\r\n *\r\n * Typical usage of this service is something like this:\r\n * ```JavaScript\r\n *      class EndUserClass {\r\n *         @filter\r\n *         public parameter1 = 'Hey';\r\n *         @filter\r\n *         public parameter2 = 'There';\r\n *      }\r\n *      let endUserClassInstance = new EndUserClass();\r\n *      let filterService = new FilterService(endUserClassInstance);\r\n * ```\r\n * Now we can use created `filtersService` instance for several cases:\r\n *  - by calling {@link getRequestState} we can get serializable representation of object state\r\n * ```JavaScript\r\n *      {\r\n *         parameter1: 'Hey',\r\n *         parameter2: 'There'\r\n *      }\r\n * ```\r\n *  - by calling {@link resetValues} we can reset values of annotated properties to initial values (or to what was specified in {@link FilterConfig.defaultValue} property).\r\n *  - by calling {@link applyParams} we can automatically apply any set of values to annotated properties (we can pass queryString object to automatically apply values from it, for example).\r\n *  - by calling {@link getRequestState} with some filters we can \"query\" the state of filters and save it to the settings storage, for example.\r\n *  - by calling {@link registerFilterTarget} you can add any count of additional objects and get their\r\n * composed state via {@link getRequestState} method as well as process them all with {@link resetValues} and {@link applyParams}.\r\n */\r\n@Injectable()\r\nexport class RTFiltersService {\r\n  /**\r\n   * Global collection of all filters configuration.\r\n   *\r\n   * Used to build {@link appliedFiltersMap} for concrete set of objects that were registered as `target objects` via {@link registerFilterTarget} for concrete service instance.\r\n   */\r\n  public static filterPropertiesMap: Map<any, FilterConfig[]> = new Map<any, FilterConfig[]>();\r\n  /**\r\n   * Collection of {@link FilterConfig} settings that matches configuration for all objects that were registered in current service instance via {@link registerFilterTarget} method.\r\n   *\r\n   * This collection is also filled up with configurations of passed `target objects` base classes since config applicability is determined by `instanceof` check.\r\n   *\r\n   * This collection is \"lazy\" and will be filled up on first call of {@link resetValues}, {@link applyParams} or {@link getRequestState} method.\r\n   */\r\n  public readonly appliedFiltersMap: Map<object, FilterConfig[]> = new Map<object, FilterConfig[]>();\r\n  /**\r\n   * @param target `target object` that will be registered with {@link registerFilterTarget} method.\r\n   */\r\n  /**\r\n   * Used to register type property as `target property` with specified filter config for later usage with {@link FiltersService}.\r\n   *\r\n   * This method is called by {@link filter} annotation, for example.\r\n   * @param targetType type definition that contains specified property declaration.\r\n   * @param propertyConfig configuration for property as a filter.\r\n   */\r\n  public static registerFilterConfig(targetType: object, propertyConfig: FilterConfig): void {\r\n    const typeConfigs = RTFiltersService.filterPropertiesMap.has(targetType)\r\n      ? RTFiltersService.filterPropertiesMap.get(targetType)\r\n      : new Array<FilterConfig>();\r\n    typeConfigs.push(propertyConfig);\r\n    RTFiltersService.filterPropertiesMap.set(targetType, typeConfigs);\r\n  }\r\n  /**\r\n   * Used to build resulted value of `target property` based on specified {@link FilterConfig}.\r\n   *\r\n   * This method is used by {@link getRequestState} and also calls oneself for the case of array values.\r\n   *\r\n   *\r\n   * In addition to {@link FilterConfig} configuration, this method checks if `target property` has method `toRequest()`. If so this method will be used to get serialized value.\r\n   *\r\n   * This convention has sense in several scenarios:\r\n   *  - Serialization of complex object can be performed by it's own method which was declared once instead of copy-paste it in {@link FilterConfig.serializeFormatter} declarations.\r\n   *  - Very tricky but sometimes useful usage of this convention is to declare `toRequest` in `Date` prototype.\r\n   *\r\n   * This gives ability to easily send `Date` objects to the server in appropriate format which server can apply or, for example, always send UTC-dates.\r\n   *\r\n   * But be accurate with this approach. There's a lot of problems with extending of embedded types.\r\n   *\r\n   * @param target `target` object which holds specified `target property`. Used as `this` scope for {@link FilterConfig.serializeFormatter} method.\r\n   * @param value raw value of `target` property.\r\n   * @param config filter configuration for `target` property.\r\n   */\r\n  private static buildFilterValue(target: object, value: any, config: FilterConfig): object {\r\n    let result = value;\r\n    if (config && config.serializeFormatter) {\r\n      return config.serializeFormatter.call(target, result);\r\n    }\r\n\r\n    result = config && config.emptyIsNull ? result || null : result;\r\n    result = config && config.coerce ? coerceValue(result) : result;\r\n    if (result && result.toRequest) {\r\n      return result.toRequest();\r\n    }\r\n    if (Array.isArray(result)) {\r\n      const temp = [];\r\n      for (let i = 0; i < result.length; i++) {\r\n        temp[i] = RTFiltersService.buildFilterValue(target, result[i], null);\r\n      }\r\n      return temp;\r\n    }\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Performs service destroy.\r\n   */\r\n  public destroy(): void {\r\n    this.appliedFiltersMap.clear();\r\n  }\r\n  /**\r\n   * Goes through all `target properties` of all `target objects` and sets their values to configured default.\r\n   *\r\n   * Default value will be determined as:\r\n   *  - If value for {@link FilterConfig.defaultValue} is specified it will be applied.\r\n   *  - Otherwise this service writes to {@link FilterConfig.defaultValue} value of `target property` at the moment of first call of\r\n   * {@link resetValues}, {@link applyParams} or {@link getRequestState}.\r\n   *\r\n   * This method performs next actions:\r\n   *  - If value specified as {@link FilterConfig.defaultValue} is function it will be called with `target object` as `this` scope. If specified value is not a function it will be used by itself.\r\n   *  - Result of previous step will be cloned by {@link cloneLiteral} function to avoid possible reference types problems.\r\n   *  - If {@link FilterConfig.parseFormatter} method is specified it will be called with previous step result as parameter.\r\n   *  - Result of previous steps is applied as value to `target property`.\r\n   */\r\n  public resetValues(): void {\r\n    this.appliedFiltersMap.forEach((targetConfig: FilterConfig[], target: { [id: string]: any }) => {\r\n      for (const config of targetConfig) {\r\n        const defaultValue = typeof config.defaultValue === 'function' ? (config.defaultValue as () => any).call(target) : config.defaultValue;\r\n        const clonedObject = cloneAsLiteral({ defaultValue });\r\n        this.setPropertyValue(\r\n          target,\r\n          config,\r\n          config.parseFormatter ? config.parseFormatter.call(target, clonedObject.defaultValue) : clonedObject.defaultValue\r\n        );\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * Goes through all `target properties` of all `target objects` and tries to find property within passed object which name is equal\r\n   * to configured {@link FilterConfig.parameterName}.\r\n   *\r\n   * If match is found, value of the property from passed object is applied to `target property` in accordance with\r\n   * {@link FilterConfig.ignoreOnAutoMap}, {@link FilterConfig.emptyIsNull}, {@link FilterConfig.coerce}, {@link FilterConfig.parseFormatter}.\r\n   * @param params - object with values to apply.\r\n   */\r\n  public applyParams(params: { [id: string]: any }): void {\r\n    this.appliedFiltersMap.forEach((targetConfig: FilterConfig[], target: { [id: string]: any }) => {\r\n      for (const config of targetConfig) {\r\n        if (params && Object.prototype.hasOwnProperty.call(params, config.parameterName) && false === config.ignoreOnAutoMap) {\r\n          let proposedVal = config.emptyIsNull ? params[config.parameterName] || null : params[config.parameterName];\r\n          proposedVal = config.coerce ? coerceValue(proposedVal) : proposedVal;\r\n          this.setPropertyValue(target, config, config.parseFormatter ? config.parseFormatter.call(target, proposedVal, params) : proposedVal);\r\n        }\r\n      }\r\n    });\r\n  }\r\n  /**\r\n   * Goes through all `target properties` of all `target objects` and applies their values to one resulted object literal.\r\n   *\r\n   * Typical usage of this method is building request to send it to the server.\r\n   *\r\n   * Names of properties in result object depends on {@link FilterConfig.parameterName}. Final values would be constructed by {@link buildFilterValue} method.\r\n   * @param filterFn - optional function to filter applied values.\r\n   * @returns resulted object literal.\r\n   */\r\n  public getRequestState(filterFn?: (config: FilterConfig, proposedValue: any, targetObject: object) => boolean): any {\r\n    const result: { [id: string]: any } = {};\r\n    this.appliedFiltersMap.forEach((targetConfig: FilterConfig[], target: { [id: string]: any }) => {\r\n      for (let config of targetConfig) {\r\n        config = { ...config };\r\n        const proposedVal = this.getPropertyValue(target, config);\r\n        if (filterFn ? filterFn(config, proposedVal, target) : true) {\r\n          const resultValue = RTFiltersService.buildFilterValue(target, proposedVal, config);\r\n          if (!config.omitIfNullOrUndefined || (resultValue !== null && typeof resultValue !== 'undefined')) {\r\n            result[config.parameterName] = resultValue;\r\n          }\r\n        }\r\n      }\r\n    });\r\n    return result;\r\n  }\r\n\r\n  /**\r\n   * Registers passed object as `target object` for current service instance.\r\n   *\r\n   * {@link getRequestState} method will compose result from objects that were registered by this method.\r\n   *\r\n   * {@link applyParams} and {@link resetValues} methods processes registered objects that were registered by this method.\r\n   * @param targets object(s) to register as `target object`.\r\n   */\r\n  public registerFilterTarget(...targets: object[]): void {\r\n    targets.forEach((target: object) => {\r\n      if (target === null || target === undefined) {\r\n        return;\r\n      }\r\n      this.appliedFiltersMap.set(target, null);\r\n      this.buildFilterTargetMap(target);\r\n    });\r\n  }\r\n  /**\r\n   * Removes passed object from `target objects` collection for current service instance.\r\n   *\r\n   * This means that {@link getRequestState}, {@link applyParams} and {@link resetValues} methods stops to process this objects.\r\n   * @param targets object(s) to remove from collection of `target object`.\r\n   */\r\n  public removeFilterTarget(...targets: object[]): void {\r\n    targets.forEach((target: object) => {\r\n      this.appliedFiltersMap.delete(target);\r\n    });\r\n  }\r\n  /**\r\n   * Builds map of settings for passed `target` object.\r\n   */\r\n  private buildFilterTargetMap(target: { [id: string]: any }): void {\r\n    let targetConfig = new Array<FilterConfig>();\r\n    RTFiltersService.filterPropertiesMap.forEach((typeConfig: FilterConfig[], type: any) => {\r\n      if (target instanceof type) {\r\n        targetConfig = targetConfig.concat(typeConfig);\r\n        for (const config of targetConfig) {\r\n          if (typeof config.defaultValue === 'undefined') {\r\n            config.defaultValue = cloneAsLiteral({\r\n              defaultValue: this.getPropertyValue(target, config)\r\n            }).defaultValue;\r\n          }\r\n        }\r\n      }\r\n    });\r\n    if (targetConfig.length > 0) {\r\n      this.appliedFiltersMap.set(target, targetConfig);\r\n    } else {\r\n      this.appliedFiltersMap.delete(target);\r\n    }\r\n  }\r\n  private getPropertyValue(target: { [id: string]: any }, config: FilterConfig) {\r\n    if (target[config.propertyName] instanceof BehaviorSubject) {\r\n      return (target[config.propertyName] as BehaviorSubject<any>).getValue();\r\n    }\r\n    // duck type reactive form control\r\n    if (!!target[config.propertyName] && !!target[config.propertyName].setValue && !!target[config.propertyName].status) {\r\n      return target[config.propertyName].value;\r\n    }\r\n    return target[config.propertyName];\r\n  }\r\n  private setPropertyValue(target: { [id: string]: any }, config: FilterConfig, value: any) {\r\n    if (!!target[config.propertyName] && target[config.propertyName] instanceof Subject) {\r\n      (target[config.propertyName] as Subject<any>).next(value);\r\n      return;\r\n    }\r\n    // duck type reactive form control\r\n    if (!!target[config.propertyName] && target[config.propertyName].setValue) {\r\n      target[config.propertyName].setValue(value);\r\n      return;\r\n    }\r\n    target[config.propertyName] = value;\r\n  }\r\n}\r\n"]}