@activejs/core
Version:
Pragmatic, Reactive State Management for JavaScript Apps
142 lines • 16.7 kB
JavaScript
import { merge } from 'rxjs';
import { Base } from './abstract-base';
import { Configuration } from './configuration';
import { Stream } from './stream';
import { checkClusterItems } from '../checks/common';
import { IteratorSymbol, makeNonEnumerable } from '../utils/funcs';
/**
* A Cluster is just a wrapper, a group, of two or more ActiveJS fundamental constructs, `Units`, `Systems`, `Actions`, or even `Clusters`.
*
* It creates a master `Observable` of the combined value of its members by merging all the provided Observable constructs.
* Whenever any of these wrapped constructs emits a value, `Cluster` emits a new combined-value.
*
* See {@link https://docs.activejs.dev/fundamentals/cluster} for more details.
*
* @category 4. Utility
*/
export class Cluster extends Base {
constructor(items, config) {
super(Object.assign(Object.assign({}, Configuration.CLUSTER), config));
/**
* The items part of this cluster, stored as key-value pairs.
*/
this.items = {};
checkClusterItems(items);
this.extractItems(items);
this.startListeningAndEmitting();
makeNonEnumerable(this);
Object.freeze(this.items);
}
/**
* The count of items part of this cluster.
*/
get itemsCount() {
return this._itemsCount;
}
// tslint:enable:variable-name
/**
* Combined value of the items part of this Cluster.
*
* @category Access Value
*/
value() {
const val = this.itemsKeys.reduce((reduced, key) => {
reduced[key] = this.items[key].value();
return reduced;
}, {});
if (Configuration.ENVIRONMENT.checkImmutability === true) {
Object.freeze(val);
}
return val;
}
/**
* A helper method that creates a stream by subscribing to the Observable returned by the param `observableProducer` callback.
*
* Ideally the callback function creates an Observable by applying `Observable.pipe`.
*
* Just know that you should catch the error in a sub-pipe (ie: do not let it propagate to the main-pipe), otherwise
* as usual the stream will stop working, and will not react on any further emissions.
*
* @param observableProducer A callback function that should return an Observable.
*
* @category Common
*/
createStream(observableProducer) {
const observable = observableProducer(this);
return new Stream(observable);
}
/**
* Select a child by providing its key.
*
* @param key The key of the child.
*
* @category Custom Cluster
*/
select(key) {
return this.items[key];
}
/**
* Performs the specified action for each child of the Cluster {@link items}. \
* It's a drop-in replacement for the `forEach` method.
*
* @param callbackFn A function that accepts up to three arguments.
* forEvery calls the callbackFn function one time for each element in the list.
* @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 Cluster
*/
forEvery(callbackFn, thisArg) {
Object.entries(this.items).forEach(([key, item], i, itemsAsEntries) => callbackFn.call(thisArg, item, key, i, itemsAsEntries));
}
/**
* @internal please do not use.
*/
[IteratorSymbol]() {
let index = 0;
const items = Object.entries(this.items);
const length = items.length;
return {
next() {
return { value: items[index++], done: index > length };
},
};
}
/**
* @internal please do not use.
*/
extractItems(items) {
this.itemsKeys = Object.keys(items).filter(key => items[key] instanceof Base);
this._itemsCount = this.itemsKeys.length;
this.itemsKeys.forEach(key => {
this.items[key] = items[key];
});
}
/**
* @internal please do not use.
*/
startListeningAndEmitting() {
this.emit();
merge(...Object.values(this.items).map(item => item.future$)).subscribe(() => this.emit());
}
/**
* @internal please do not use.
*/
emit(value = this.combinedEmittedValues()) {
if (Configuration.ENVIRONMENT.checkImmutability === true) {
Object.freeze(value);
}
super.emit(value);
}
/**
* @internal please do not use.
*/
combinedEmittedValues() {
return this.itemsKeys.reduce((reduced, key) => {
// tslint:disable-next-line:no-string-literal
reduced[key] = this.items[key]['emittedValue'];
return reduced;
}, {});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cluster.js","sourceRoot":"/home/runner/work/activejs/activejs/packages/core/src/","sources":["lib/cluster.ts"],"names":[],"mappings":"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","sourcesContent":["import {merge} from 'rxjs';\nimport {Base} from './abstract-base';\nimport {Configuration} from './configuration';\nimport {Stream} from './stream';\nimport {\n  ClusterConfig,\n  ClusterItems,\n  ClusterStreamObservableProducer,\n  InstancesMapToValuesMap,\n} from '../models';\nimport {checkClusterItems} from '../checks/common';\nimport {IteratorSymbol, makeNonEnumerable} from '../utils/funcs';\n\n/**\n * A Cluster is just a wrapper, a group, of two or more ActiveJS fundamental constructs, `Units`, `Systems`, `Actions`, or even `Clusters`.\n *\n * It creates a master `Observable` of the combined value of its members by merging all the provided Observable constructs.\n * Whenever any of these wrapped constructs emits a value, `Cluster` emits a new combined-value.\n *\n * See {@link https://docs.activejs.dev/fundamentals/cluster} for more details.\n *\n * @category 4. Utility\n */\nexport class Cluster<\n  T extends ClusterItems = ClusterItems,\n  K extends keyof T = keyof T,\n  V = InstancesMapToValuesMap<T>\n> extends Base<V> {\n  // tslint:disable:variable-name\n\n  /**\n   * Configured options. \\\n   * Combination of global-options {@link GlobalUnitConfig} and the options passed on instantiation.\n   */\n  readonly config: Readonly<ClusterConfig>;\n\n  /**\n   * @internal please do not use.\n   */\n  private itemsKeys: K[];\n\n  /**\n   * The items part of this cluster, stored as key-value pairs.\n   */\n  readonly items: Readonly<T> = {} as any;\n\n  /**\n   * @internal please do not use.\n   */\n  private _itemsCount: number;\n\n  /**\n   * The count of items part of this cluster.\n   */\n  get itemsCount(): number {\n    return this._itemsCount;\n  }\n\n  // tslint:enable:variable-name\n\n  /**\n   * Combined value of the items part of this Cluster.\n   *\n   * @category Access Value\n   */\n  value() {\n    const val = this.itemsKeys.reduce((reduced, key) => {\n      reduced[key] = this.items[key].value();\n      return reduced;\n    }, {} as any) as V;\n    if (Configuration.ENVIRONMENT.checkImmutability === true) {\n      Object.freeze(val);\n    }\n    return val;\n  }\n\n  constructor(items: T, config?: ClusterConfig) {\n    super({\n      ...Configuration.CLUSTER,\n      ...config,\n    });\n\n    checkClusterItems(items);\n\n    this.extractItems(items);\n    this.startListeningAndEmitting();\n\n    makeNonEnumerable(this);\n    Object.freeze(this.items);\n  }\n\n  /**\n   * A helper method that creates a stream by subscribing to the Observable returned by the param `observableProducer` callback.\n   *\n   * Ideally the callback function creates an Observable by applying `Observable.pipe`.\n   *\n   * Just know that you should catch the error in a sub-pipe (ie: do not let it propagate to the main-pipe), otherwise\n   * as usual the stream will stop working, and will not react on any further emissions.\n   *\n   * @param observableProducer A callback function that should return an Observable.\n   *\n   * @category Common\n   */\n  createStream<R>(observableProducer: ClusterStreamObservableProducer<this, R>): Stream {\n    const observable = observableProducer(this);\n\n    return new Stream(observable);\n  }\n\n  /**\n   * Select a child by providing its key.\n   *\n   * @param key The key of the child.\n   *\n   * @category Custom Cluster\n   */\n  select<k extends K>(key: k): T[k] {\n    return this.items[key];\n  }\n\n  /**\n   * Performs the specified action for each child of the Cluster {@link items}. \\\n   * It's a drop-in replacement for the `forEach` method.\n   *\n   * @param callbackFn A function that accepts up to three arguments.\n   * forEvery calls the callbackFn function one time for each element in the list.\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 Cluster\n   */\n  forEvery(\n    callbackFn: (item: T[K], key: K, index: number, entries: [K, T[K]][]) => void,\n    thisArg?: any\n  ): void {\n    Object.entries(this.items).forEach(([key, item], i, itemsAsEntries) =>\n      callbackFn.call(thisArg, item, key, i, itemsAsEntries)\n    );\n  }\n\n  /** Iterator */\n  [Symbol.iterator](): Iterator<[K, T[K]]>;\n  /**\n   * @internal please do not use.\n   */\n  [IteratorSymbol](): Iterator<[K, T[K]]> {\n    let index = 0;\n    const items = Object.entries(this.items) as [K, T[K]][];\n    const length: number = items.length;\n\n    return {\n      next(): IteratorResult<[K, T[K]]> {\n        return {value: items[index++], done: index > length};\n      },\n    };\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  private extractItems(items: T): void {\n    this.itemsKeys = Object.keys(items).filter(key => items[key] instanceof Base) as K[];\n    this._itemsCount = this.itemsKeys.length;\n\n    this.itemsKeys.forEach(key => {\n      (this.items as T)[key] = items[key];\n    });\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  private startListeningAndEmitting(): void {\n    this.emit();\n    merge(...Object.values(this.items).map(item => item.future$)).subscribe(() => this.emit());\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  protected emit(value = this.combinedEmittedValues()): void {\n    if (Configuration.ENVIRONMENT.checkImmutability === true) {\n      Object.freeze(value);\n    }\n    super.emit(value);\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  private combinedEmittedValues() {\n    return this.itemsKeys.reduce((reduced, key) => {\n      // tslint:disable-next-line:no-string-literal\n      reduced[key] = this.items[key]['emittedValue'];\n      return reduced;\n    }, {} as any) as V;\n  }\n}\n"]}