@activejs/core
Version:
Pragmatic, Reactive State Management for JavaScript Apps
258 lines • 32 kB
JavaScript
import { Configuration } from './configuration';
import { NonPrimitiveUnitBase } from './abstract-non-primitive-unit-base';
import { isDict, isObject, isValidKey, IteratorSymbol, makeNonEnumerable } from '../utils/funcs';
import { EventDictUnitAssign, EventDictUnitDelete, EventDictUnitSet, } from '../models';
/**
* DictUnit is a reactive storage Unit that is loosely based on `Map`.
*
* It only accepts plain dictionary `object` as its value.
* It ensures that at any point of time the value would always be a dictionary `object`.
*
* Learn more about Units [here](https://docs.activejs.dev/fundamentals/units). \
* Learn more about DictUnit [here](https://docs.activejs.dev/fundamentals/units/dictunit).
*
* Just like every other Non-Primitive ActiveJS Unit:
* - DictUnit extends {@link NonPrimitiveUnitBase}
* - Which further extends {@link UnitBase}, {@link Base} and `Observable`
*
* @category 1. Units
*/
export class DictUnit extends NonPrimitiveUnitBase {
constructor(config) {
super(Object.assign(Object.assign({}, Configuration.DICT_UNIT), config));
makeNonEnumerable(this);
}
/**
* The length of keys of the properties in the dictionary {@link value}.
*/
get length() {
return this.objectKeys().length;
}
/**
* Indicates whether the length of the keys of the properties in the dictionary {@link value} is 0 or not.
*/
get isEmpty() {
return this.length === 0;
}
/**
* @internal please do not use.
*/
defaultValue() {
return {};
}
/**
* Extends {@link UnitBase.wouldDispatch} and adds additional check for Object dictionary {@link isDict},
* which cannot be bypassed even by using {@link force}.
*
* @param value The value to be dispatched.
* @param force Whether dispatch-checks should be bypassed or not.
* @returns A boolean indicating whether the param `value` would pass the dispatch-checks if dispatched.
*
* @category Common Units
*/
wouldDispatch(value, force) {
return this.isValidValue(value) && super.wouldDispatch(value, force);
}
/**
* Adds a property by setting given property-value on the given key in the dictionary {@link value}. \
* Also, dispatches it as new dictionary, without mutating the current {@link value}.
*
* It only works if the Unit is not frozen and the `key` is either `string` or `number`.
*
* @param key The name of the property.
* @param value The property-value.
*
* @triggers {@link EventDictUnitSet}
* @category Custom DictUnit
*/
set(key, value) {
var _a;
if (this.isFrozen || !isValidKey(key)) {
return;
}
this.checkSerializabilityMaybe(value);
const dictShallowCopy = Object.assign({}, this.rawValue());
dictShallowCopy[key] = this.deepCopyMaybe(value);
this.updateValueAndCache(dictShallowCopy);
if (((_a = this.eventsSubject) === null || _a === void 0 ? void 0 : _a.observers.length) && !this.isMuted) {
this.eventsSubject.next(new EventDictUnitSet(key, value));
}
}
/**
* Deletes properties with given keys from the dictionary value. See {@link value}. \
* Deletion is performed on a copy of the value, which is then dispatched, without mutating the current value.
*
* It only works if the Unit is not frozen, and the value is not empty, \
* and at least one of the passed keys exist in the value.
* ie: at least 1 key value pair exists in the dictionary.
*
* @param keys The names of the properties to be removed.
* @returns The removed properties or an empty `object-literal`.
*
* @triggers {@link EventDictUnitDelete}
* @category Custom DictUnit
*/
delete(...keys) {
var _a;
keys = keys.filter(key => this.has(key));
if (this.isFrozen || this.isEmpty || !keys.length) {
return {};
}
const dictShallowCopy = Object.assign({}, this.rawValue());
const removedProps = {};
keys.forEach(key => {
removedProps[key] = this.deepCopyMaybe(dictShallowCopy[key]);
delete dictShallowCopy[key];
});
this.updateValueAndCache(dictShallowCopy);
if (((_a = this.eventsSubject) === null || _a === void 0 ? void 0 : _a.observers.length) && !this.isMuted) {
this.eventsSubject.next(new EventDictUnitDelete(removedProps));
}
return removedProps;
}
/**
* Deletes properties from the dictionary {@link value} where the predicate returns `true`. \
* Also, dispatches it as new dictionary, without mutating the current {@link value}.
*
* It only works if the Unit is not frozen, and
* the predicate is a function, and the dictionary is not empty.
*
* @param predicate A callback function that gets called for every property in the dictionary
* with the property-value and key as arguments.
* @returns The removed properties, or an empty `object-literal`.
*
* @triggers {@link EventDictUnitDelete}
* @category Custom DictUnit
*/
deleteIf(predicate) {
var _a;
if (this.isFrozen || typeof predicate !== 'function' || this.isEmpty) {
return {};
}
const dictShallowCopy = Object.assign({}, this.rawValue());
const removedProps = {};
Object.keys(dictShallowCopy).forEach((key, index) => {
if (predicate(this.deepCopyMaybe(dictShallowCopy[key]), key, index)) {
removedProps[key] = dictShallowCopy[key];
delete dictShallowCopy[key];
}
});
this.updateValueAndCache(dictShallowCopy);
if (((_a = this.eventsSubject) === null || _a === void 0 ? void 0 : _a.observers.length) && !this.isMuted) {
this.eventsSubject.next(new EventDictUnitDelete(removedProps));
}
return removedProps;
}
/**
* Copy the values of all the enumerable own properties from one or more source objects to the dictionary. \
* Also, dispatches it as new dictionary, without mutating the current {@link value}.
*
* It only works if the Unit is not frozen, and at least 1 source is provided, and it is a non-null object.
* eg: `array`, `object`
*
* @param sources The source objects from which to copy properties.
*
* @triggers {@link EventDictUnitAssign}
* @category Custom DictUnit
*/
assign(...sources) {
var _a;
sources = sources.filter(isObject);
if (this.isFrozen || !sources.length) {
return;
}
this.checkSerializabilityMaybe(sources);
const dictShallowCopy = Object.assign({}, this.rawValue());
const newProps = Object.assign({}, ...sources);
this.updateValueAndCache(Object.assign(dictShallowCopy, this.deepCopyMaybe(newProps)));
if (((_a = this.eventsSubject) === null || _a === void 0 ? void 0 : _a.observers.length) && !this.isMuted) {
this.eventsSubject.next(new EventDictUnitAssign(sources, newProps));
}
}
/**
* Returns the value of the property with the name equal to the given key in the dictionary {@link value}.
*
* It only returns own-properties, e.g.: key 'toString' would return `undefined`.
*
* @param key The name of the property.
*
* @category Custom DictUnit
*/
get(key) {
return this.hasOwnProperty(key) ? this.deepCopyMaybe(this.rawValue()[key]) : undefined;
}
/**
* Returns whether a property with the given key exists in the dictionary {@link value}.
*
* @param key The name of the property.
*
* @category Custom DictUnit
*/
has(key) {
return this.hasOwnProperty(key);
}
/**
* Finds direct properties of the dictionary that have a direct child property
* that matches with `key` and `value` passed as params.
*
* @example
* ```ts
* const initialValue = {'first': {b: 1}, 'second': {b: 1, b2: 2}, 'third': {c: 1}, 'fourth': {b: null}};
* const dict = new DictUnit({initialValue});
* const itemsFound = dict.findByProp('b', 1);
* console.log(itemsFound); // logs [['first', {b: 1}], ['second', {b: 1, b2: 2}]]
* ```
*
* @param key The key of the property whose value needs to be matched against param `value`.
* @param value A primitive value that will be matched against every item's prop-value using equality operator.
* @param strictEquality A flag governing whether the value be matched using `===` or `==` operator.
* Default is `true`, ie: strict equality `===`. Pass `false` to use `==` instead.
* @returns An `array` of key/values of the matched properties, an empty `array` otherwise.
*
* @category Custom DictUnit
*/
findByProp(key, value, strictEquality = true) {
if (this.isEmpty) {
return [];
}
return this.deepCopyMaybe(Object.entries(this.rawValue()).filter(([propKey, prop]) => isObject(prop) &&
(strictEquality === false
? // tslint:disable-next-line:triple-equals
prop[key] == value
: prop[key] === value)));
}
/**
* Performs the specified action for each property in the object value. See {@link value}. \
* It's a drop-in replacement for the `forEach` method.
*
* @param callbackFn A function that accepts up to two arguments.
* forEvery calls the callbackFn function one time for each property in the object value.
* @param thisArg An object to which this keyword can refer in the callbackFn function.
* If thisArg is omitted, undefined is used as this value.
*
* @category Custom DictUnit
*/
forEvery(callbackFn, thisArg) {
this.objectEntries().forEach(([key, value], i, valueEntries) => callbackFn.call(thisArg, value, key, i, valueEntries));
}
/**
* @internal please do not use.
*/
[IteratorSymbol]() {
let index = 0;
const items = this.objectEntries();
const length = items.length;
return {
next() {
return { value: items[index++], done: index > length };
},
};
}
/**
* @internal please do not use.
*/
isValidValue(value) {
return isDict(value);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dict-unit.js","sourceRoot":"/home/runner/work/activejs/activejs/packages/core/src/","sources":["lib/dict-unit.ts"],"names":[],"mappings":"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","sourcesContent":["import {Observable, Subject} from 'rxjs';\nimport {Configuration} from './configuration';\nimport {UnitBase} from './abstract-unit-base';\nimport {NonPrimitiveUnitBase} from './abstract-non-primitive-unit-base';\nimport {isDict, isObject, isValidKey, IteratorSymbol, makeNonEnumerable} from '../utils/funcs';\nimport {\n  DictUnitEvents,\n  DictValue,\n  EventDictUnitAssign,\n  EventDictUnitDelete,\n  EventDictUnitSet,\n  KOf,\n  UnitConfig,\n} from '../models';\n\n/**\n * DictUnit is a reactive storage Unit that is loosely based on `Map`.\n *\n * It only accepts plain dictionary `object` as its value.\n * It ensures that at any point of time the value would always be a dictionary `object`.\n *\n * Learn more about Units [here](https://docs.activejs.dev/fundamentals/units). \\\n * Learn more about DictUnit [here](https://docs.activejs.dev/fundamentals/units/dictunit).\n *\n * Just like every other Non-Primitive ActiveJS Unit:\n * - DictUnit extends {@link NonPrimitiveUnitBase}\n * - Which further extends {@link UnitBase}, {@link Base} and `Observable`\n *\n * @category 1. Units\n */\nexport class DictUnit<\n  T extends DictValue<T>,\n  K extends keyof T = keyof T,\n  V extends T[K] = T[K]\n> extends NonPrimitiveUnitBase<T> {\n  /**\n   * @internal please do not use.\n   */\n  protected readonly eventsSubject: Subject<DictUnitEvents<T>>;\n  /**\n   * On-demand observable events.\n   */\n  readonly events$: Observable<DictUnitEvents<T>>;\n\n  /**\n   * The length of keys of the properties in the dictionary {@link value}.\n   */\n  get length(): number {\n    return this.objectKeys().length;\n  }\n\n  /**\n   * Indicates whether the length of the keys of the properties in the dictionary {@link value} is 0 or not.\n   */\n  get isEmpty(): boolean {\n    return this.length === 0;\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  protected defaultValue(): T {\n    return {} as T;\n  }\n\n  constructor(config?: UnitConfig<T>) {\n    super({\n      ...(Configuration.DICT_UNIT as UnitConfig<T>),\n      ...config,\n    });\n\n    makeNonEnumerable(this);\n  }\n\n  /**\n   * Extends {@link UnitBase.wouldDispatch} and adds additional check for Object dictionary {@link isDict},\n   * which cannot be bypassed even by using {@link force}.\n   *\n   * @param value The value to be dispatched.\n   * @param force Whether dispatch-checks should be bypassed or not.\n   * @returns A boolean indicating whether the param `value` would pass the dispatch-checks if dispatched.\n   *\n   * @category Common Units\n   */\n  wouldDispatch(value: T, force?: boolean): boolean {\n    return this.isValidValue(value) && super.wouldDispatch(value, force);\n  }\n\n  /**\n   * Adds a property by setting given property-value on the given key in the dictionary {@link value}. \\\n   * Also, dispatches it as new dictionary, without mutating the current {@link value}.\n   *\n   * It only works if the Unit is not frozen and the `key` is either `string` or `number`.\n   *\n   * @param key The name of the property.\n   * @param value The property-value.\n   *\n   * @triggers {@link EventDictUnitSet}\n   * @category Custom DictUnit\n   */\n  set<k extends K>(key: k, value: T[k]): void {\n    if (this.isFrozen || !isValidKey(key)) {\n      return;\n    }\n    this.checkSerializabilityMaybe(value);\n\n    const dictShallowCopy = {...this.rawValue()};\n    dictShallowCopy[key] = this.deepCopyMaybe(value);\n    this.updateValueAndCache(dictShallowCopy);\n\n    if (this.eventsSubject?.observers.length && !this.isMuted) {\n      this.eventsSubject.next(new EventDictUnitSet(key, value));\n    }\n  }\n\n  /**\n   * Deletes properties with given keys from the dictionary value. See {@link value}. \\\n   * Deletion is performed on a copy of the value, which is then dispatched, without mutating the current value.\n   *\n   * It only works if the Unit is not frozen, and the value is not empty, \\\n   * and at least one of the passed keys exist in the value.\n   * ie: at least 1 key value pair exists in the dictionary.\n   *\n   * @param keys The names of the properties to be removed.\n   * @returns The removed properties or an empty `object-literal`.\n   *\n   * @triggers {@link EventDictUnitDelete}\n   * @category Custom DictUnit\n   */\n  delete<k extends K>(...keys: k[]): {[key in k]: T[k]} {\n    keys = keys.filter(key => this.has(key));\n    if (this.isFrozen || this.isEmpty || !keys.length) {\n      return {} as any;\n    }\n\n    const dictShallowCopy: T = {...this.rawValue()};\n    const removedProps: {[key in k]: T[k]} = {} as any;\n\n    keys.forEach(key => {\n      removedProps[key] = this.deepCopyMaybe(dictShallowCopy[key]);\n      delete dictShallowCopy[key];\n    });\n\n    this.updateValueAndCache(dictShallowCopy);\n\n    if (this.eventsSubject?.observers.length && !this.isMuted) {\n      this.eventsSubject.next(new EventDictUnitDelete(removedProps));\n    }\n    return removedProps;\n  }\n\n  /**\n   * Deletes properties from the dictionary {@link value} where the predicate returns `true`. \\\n   * Also, dispatches it as new dictionary, without mutating the current {@link value}.\n   *\n   * It only works if the Unit is not frozen, and\n   * the predicate is a function, and the dictionary is not empty.\n   *\n   * @param predicate A callback function that gets called for every property in the dictionary\n   * with the property-value and key as arguments.\n   * @returns The removed properties, or an empty `object-literal`.\n   *\n   * @triggers {@link EventDictUnitDelete}\n   * @category Custom DictUnit\n   */\n  deleteIf(predicate: (value: V, key: K, index: number) => boolean): T {\n    if (this.isFrozen || typeof predicate !== 'function' || this.isEmpty) {\n      return {} as any;\n    }\n\n    const dictShallowCopy = {...this.rawValue()};\n    const removedProps: T = {} as any;\n\n    (Object.keys(dictShallowCopy) as K[]).forEach((key: K, index) => {\n      if (predicate(this.deepCopyMaybe(dictShallowCopy[key]), key, index)) {\n        removedProps[key] = dictShallowCopy[key];\n        delete dictShallowCopy[key];\n      }\n    });\n\n    this.updateValueAndCache(dictShallowCopy);\n\n    if (this.eventsSubject?.observers.length && !this.isMuted) {\n      this.eventsSubject.next(new EventDictUnitDelete(removedProps));\n    }\n    return removedProps;\n  }\n\n  /**\n   * Copy the values of all the enumerable own properties from one or more source objects to the dictionary. \\\n   * Also, dispatches it as new dictionary, without mutating the current {@link value}.\n   *\n   * It only works if the Unit is not frozen, and at least 1 source is provided, and it is a non-null object.\n   * eg: `array`, `object`\n   *\n   * @param sources The source objects from which to copy properties.\n   *\n   * @triggers {@link EventDictUnitAssign}\n   * @category Custom DictUnit\n   */\n  assign(...sources: T[]): void {\n    sources = sources.filter(isObject);\n    if (this.isFrozen || !sources.length) {\n      return;\n    }\n    this.checkSerializabilityMaybe(sources);\n\n    const dictShallowCopy = {...this.rawValue()};\n    const newProps = Object.assign({}, ...sources);\n    this.updateValueAndCache(Object.assign(dictShallowCopy, this.deepCopyMaybe(newProps)));\n\n    if (this.eventsSubject?.observers.length && !this.isMuted) {\n      this.eventsSubject.next(new EventDictUnitAssign(sources, newProps));\n    }\n  }\n\n  /**\n   * Returns the value of the property with the name equal to the given key in the dictionary {@link value}.\n   *\n   * It only returns own-properties, e.g.: key 'toString' would return `undefined`.\n   *\n   * @param key The name of the property.\n   *\n   * @category Custom DictUnit\n   */\n  get<k extends K>(key: k): T[k] | undefined {\n    return this.hasOwnProperty(key) ? this.deepCopyMaybe(this.rawValue()[key]) : undefined;\n  }\n\n  /**\n   * Returns whether a property with the given key exists in the dictionary {@link value}.\n   *\n   * @param key The name of the property.\n   *\n   * @category Custom DictUnit\n   */\n  has<k extends K>(key: k): boolean {\n    return this.hasOwnProperty(key);\n  }\n\n  /**\n   * Finds direct properties of the dictionary that have a direct child property\n   * that matches with `key` and `value` passed as params.\n   *\n   * @example\n   * ```ts\n   * const initialValue = {'first': {b: 1}, 'second': {b: 1, b2: 2}, 'third': {c: 1}, 'fourth': {b: null}};\n   * const dict = new DictUnit({initialValue});\n   * const itemsFound = dict.findByProp('b', 1);\n   * console.log(itemsFound); // logs [['first', {b: 1}], ['second', {b: 1, b2: 2}]]\n   * ```\n   *\n   * @param key The key of the property whose value needs to be matched against param `value`.\n   * @param value A primitive value that will be matched against every item's prop-value using equality operator.\n   * @param strictEquality A flag governing whether the value be matched using `===` or `==` operator.\n   * Default is `true`, ie: strict equality `===`. Pass `false` to use `==` instead.\n   * @returns An `array` of key/values of the matched properties, an empty `array` otherwise.\n   *\n   * @category Custom DictUnit\n   */\n  findByProp<k extends KOf<V>>(\n    key: k,\n    value: string | number | boolean,\n    strictEquality = true\n  ): [K, V][] {\n    if (this.isEmpty) {\n      return [];\n    }\n\n    return this.deepCopyMaybe(\n      (Object.entries<V>(this.rawValue()) as [K, V][]).filter(\n        ([propKey, prop]) =>\n          isObject(prop) &&\n          (strictEquality === false\n            ? // tslint:disable-next-line:triple-equals\n              prop[key as string | number] == value\n            : prop[key as string | number] === value)\n      )\n    );\n  }\n\n  /**\n   * Performs the specified action for each property in the object value. See {@link value}. \\\n   * It's a drop-in replacement for the `forEach` method.\n   *\n   * @param callbackFn A function that accepts up to two arguments.\n   * forEvery calls the callbackFn function one time for each property in the object value.\n   * @param thisArg An object to which this keyword can refer in the callbackFn function.\n   * If thisArg is omitted, undefined is used as this value.\n   *\n   * @category Custom DictUnit\n   */\n  forEvery(\n    callbackFn: (value: V, key: K, index: number, entries: [K, V][]) => void,\n    thisArg?: any\n  ): void {\n    this.objectEntries().forEach(([key, value], i, valueEntries) =>\n      callbackFn.call(thisArg, value, key, i, valueEntries)\n    );\n  }\n\n  /** Iterator */\n  [Symbol.iterator](): Iterator<[string, V]>;\n  /**\n   * @internal please do not use.\n   */\n  [IteratorSymbol](): Iterator<[string, V]> {\n    let index = 0;\n    const items: [string, V][] = this.objectEntries();\n    const length: number = items.length;\n\n    return {\n      next(): IteratorResult<[string, V]> {\n        return {value: items[index++], done: index > length};\n      },\n    };\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  protected isValidValue(value: any): boolean {\n    return isDict(value);\n  }\n}\n"]}