@activejs/core
Version:
Pragmatic, Reactive State Management for JavaScript Apps
205 lines • 26 kB
JavaScript
import '../../../../LICENSE';
import { BehaviorSubject, Observable, Subject } from 'rxjs';
import { EventReplay } from '../models';
import { getLocationId, isFunction, isValidId } from '../utils/funcs';
import { Configuration, UniqueIdsAndLocationIdMap } from './configuration';
/**
* This is the most basic building block of ActiveJS.
*
* Base serves as the base for all fundamental ActiveJS constructs: Units, Systems, Actions and Clusters.
*
* This is an internal construct, normally you'd never have to use this class directly.
* However, if you're just reading the documentation, or want to learn more about how ActiveJS works,
* or want to extend this class to build something on your own, please continue.
*
* It extends RxJS `Observable`.
* Source of this Observable is either a BehaviorSubject or Subject depending on the {@link BaseConfig.replay} flag.
* By default, it's a BehaviourSubject for the Units, Systems and Clusters; and a Subject for Actions.
*
* There's another non-replaying Observable named `future$` to observe the value, whose source is always a simple Subject,
* This Subject also serves as the source for default extended Observable when {@link BaseConfig.replay} is `false`.
*
* In simple terms Base is an elaborate RxJS Subject like construct, with custom features like replay on demand.
* Although that's just one aspect of Base.
*
* It also implements `Object.prototype` methods
* to make working with the stored value a bit easier and efficient.
*
* Other than that, It also provides functionalities like: On-demand Observable custom-event, to listen to events like manual replay.
*
* @category 2. Abstract
*/
export class Base extends Observable {
// tslint:enable:variable-name
constructor(config) {
super();
/**
* @internal please do not use.
*/
this.futureSubject = new Subject();
/**
* An Observable to observe future values,
* unlike the default Observable it doesn't replay when subscribed to,
* rather it waits for the next value.
*/
this.future$ = this.futureSubject.asObservable();
/**
* @internal please do not use.
*/
this._emitCount = 0;
this.config = Object.assign({}, config);
if (this.config.id !== undefined) {
if (!isValidId(this.config.id)) {
throw new TypeError(`Invalid id provided, expected a non-empty string, got ${String(this.config.id)}`);
}
if (Configuration.ENVIRONMENT.checkUniqueId === true) {
const locationId = getLocationId(this);
if (UniqueIdsAndLocationIdMap[this.config.id] != null &&
UniqueIdsAndLocationIdMap[this.config.id] !== locationId) {
throw new TypeError(`Duplicate id "${this.config.id}" detected by "checkUniqueId" check, consider assigning a unique id.`);
}
UniqueIdsAndLocationIdMap[this.config.id] = locationId;
}
}
else if (this.config.persistent === true) {
throw new TypeError(`An id is required for persistence to work.`);
}
if (this.config.replay === false) {
this.sourceSubject = this.futureSubject;
this.source = this.future$;
}
else {
this.sourceSubject = new BehaviorSubject(undefined);
this.source = this.sourceSubject.asObservable();
}
this.setupEvents();
Object.freeze(this.config);
}
/**
* A counter to keep track of how many times has a Unit, System, Action or Cluster emitted.
* @returns Number of times a Unit, System, Action or Cluster has emitted.
*/
get emitCount() {
return this._emitCount;
}
/**
* Current value.
* Used internally, for operations that don't mutate the value.
*
* @internal please do not use.
*
* @category Access Value
*/
rawValue() {
return this.value();
}
/**
* Creates a new Observable using the default Observable as source.
* Use this to conceal other aspects of a Unit, System, Action or Cluster except the Observable part.
*
* @returns An Observable with the value of a Unit, System, Action or Cluster.
*
* @category Common
*/
asObservable() {
const observable = new Observable();
observable.source = this.source;
return observable;
}
/**
* To manually re-emit the last emitted value again.
*
* @triggers {@link EventReplay}
* @category Common
*/
replay() {
var _a;
this.emit(this.emittedValue);
if ((_a = this.eventsSubject) === null || _a === void 0 ? void 0 : _a.observers.length) {
this.eventsSubject.next(new EventReplay(this.emittedValue));
}
}
/**
* Converts the value to JSON string, using `JSON.stringify`.
*
* @category Common
*/
toJsonString() {
return JSON.stringify(this.rawValue());
}
/**
* Returns the {@link rawValue},
* JavaScript automatically invokes it when encountering an object where a primitive value is expected.
*
* @alias {@link rawValue}
* This method is not intended to be used by developers, use {@link rawValue} instead.
* It only exists to be used by JavaScript implicitly.
*
* @hidden
* @category Customised Object.prototype
*/
valueOf() {
return this.rawValue();
}
/**
* Returns the {@link rawValue}.
* JavaScript automatically invokes it when `JSON.stringify` is invoked on an object.
*
* @alias {@link rawValue}
* This method is not intended to be used by developers, use {@link rawValue} instead.
* It only exists to be used by `JSON.stringify` implicitly.
*
* @hidden
* @category Common
*/
toJSON() {
return this.rawValue();
}
/**
* @internal please do not use.
*/
emit(value = this.value()) {
++this._emitCount;
this.emittedValue = value;
if (this.sourceSubject !== this.futureSubject) {
this.sourceSubject.next(value);
}
this.futureSubject.next(value);
}
/**
* @internal please do not use.
*/
setupEvents() {
Object.defineProperty(this, 'events$', {
get() {
if (this._events) {
return this._events;
}
this.eventsSubject = new Subject();
this._events = this.eventsSubject.asObservable();
Object.defineProperty(this, 'eventsSubject', { enumerable: false });
Object.defineProperty(this, '_events', { enumerable: false });
return this._events;
},
enumerable: false,
});
}
}
/**
* @internal please do not use.
*/
const MethodsNotToImplement = [
...Object.getOwnPropertyNames(Observable.prototype),
...Object.getOwnPropertyNames(Base.prototype),
];
Object.getOwnPropertyNames(Object.prototype).forEach(method => {
if (!isFunction(Object.prototype[method]) || MethodsNotToImplement.includes(method)) {
return;
}
Object.defineProperty(Base.prototype, method, {
value(...args) {
return this.rawValue()[method](...args);
},
});
});
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstract-base.js","sourceRoot":"/home/runner/work/activejs/activejs/packages/core/src/","sources":["lib/abstract-base.ts"],"names":[],"mappings":"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","sourcesContent":["import '../../../../LICENSE';\nimport {BehaviorSubject, Observable, Subject} from 'rxjs';\nimport {BaseConfig, BaseEvents, EventReplay, UnitConfig} from '../models';\nimport {getLocationId, isFunction, isValidId} from '../utils/funcs';\nimport {Configuration, UniqueIdsAndLocationIdMap} from './configuration';\n\n/**\n * This is the most basic building block of ActiveJS.\n *\n * Base serves as the base for all fundamental ActiveJS constructs: Units, Systems, Actions and Clusters.\n *\n * This is an internal construct, normally you'd never have to use this class directly.\n * However, if you're just reading the documentation, or want to learn more about how ActiveJS works,\n * or want to extend this class to build something on your own, please continue.\n *\n * It extends RxJS `Observable`.\n * Source of this Observable is either a BehaviorSubject or Subject depending on the {@link BaseConfig.replay} flag.\n * By default, it's a BehaviourSubject for the Units, Systems and Clusters; and a Subject for Actions.\n *\n * There's another non-replaying Observable named `future$` to observe the value, whose source is always a simple Subject,\n * This Subject also serves as the source for default extended Observable when {@link BaseConfig.replay} is `false`.\n *\n * In simple terms Base is an elaborate RxJS Subject like construct, with custom features like replay on demand.\n * Although that's just one aspect of Base.\n *\n * It also implements `Object.prototype` methods\n * to make working with the stored value a bit easier and efficient.\n *\n * Other than that, It also provides functionalities like: On-demand Observable custom-event, to listen to events like manual replay.\n *\n * @category 2. Abstract\n */\nexport abstract class Base<T> extends Observable<T> {\n  // tslint:disable:variable-name\n\n  /**\n   * Configured options.\n   * Combination of applicable global-options and the options passed on instantiation.\n   */\n  readonly config: Readonly<BaseConfig>;\n\n  /**\n   * @internal please do not use.\n   */\n  protected readonly sourceSubject: Subject<T> | BehaviorSubject<T>;\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  readonly source: Observable<T>;\n\n  /**\n   * @internal please do not use.\n   */\n  protected eventsSubject: Subject<BaseEvents<T> | any>;\n  /**\n   * On-demand observable events.\n   * See {@link https://docs.activejs.dev/guides/events} for more details.\n   */\n  readonly events$: Observable<BaseEvents<T> | any>;\n\n  /**\n   * @internal please do not use.\n   */\n  private _events: Observable<BaseEvents<T>>;\n\n  /**\n   * @internal please do not use.\n   */\n  private readonly futureSubject = new Subject<T>();\n  /**\n   * An Observable to observe future values,\n   * unlike the default Observable it doesn't replay when subscribed to,\n   * rather it waits for the next value.\n   */\n  readonly future$: Observable<T> = this.futureSubject.asObservable();\n\n  /**\n   * @internal please do not use.\n   */\n  protected emittedValue: T;\n\n  /**\n   * @internal please do not use.\n   */\n  private _emitCount = 0;\n\n  /**\n   * A counter to keep track of how many times has a Unit, System, Action or Cluster emitted.\n   * @returns Number of times a Unit, System, Action or Cluster has emitted.\n   */\n  get emitCount(): number {\n    return this._emitCount;\n  }\n\n  /**\n   * Current value.\n   *\n   * @category Access Value\n   */\n  abstract value(): T;\n\n  /**\n   * Current value.\n   * Used internally, for operations that don't mutate the value.\n   *\n   * @internal please do not use.\n   *\n   * @category Access Value\n   */\n  protected rawValue(): T {\n    return this.value();\n  }\n\n  // tslint:enable:variable-name\n\n  protected constructor(config?: BaseConfig) {\n    super();\n\n    this.config = {...config};\n\n    if (this.config.id !== undefined) {\n      if (!isValidId(this.config.id)) {\n        throw new TypeError(\n          `Invalid id provided, expected a non-empty string, got ${String(this.config.id)}`\n        );\n      }\n      if (Configuration.ENVIRONMENT.checkUniqueId === true) {\n        const locationId = getLocationId(this);\n        if (\n          UniqueIdsAndLocationIdMap[this.config.id] != null &&\n          UniqueIdsAndLocationIdMap[this.config.id] !== locationId\n        ) {\n          throw new TypeError(\n            `Duplicate id \"${this.config.id}\" detected by \"checkUniqueId\" check, consider assigning a unique id.`\n          );\n        }\n        UniqueIdsAndLocationIdMap[this.config.id] = locationId;\n      }\n    } else if ((this.config as UnitConfig<any>).persistent === true) {\n      throw new TypeError(`An id is required for persistence to work.`);\n    }\n\n    if (this.config.replay === false) {\n      this.sourceSubject = this.futureSubject;\n      (this as any).source = this.future$;\n    } else {\n      this.sourceSubject = new BehaviorSubject(undefined);\n      (this as any).source = this.sourceSubject.asObservable();\n    }\n\n    this.setupEvents();\n    Object.freeze(this.config);\n  }\n\n  /**\n   * Creates a new Observable using the default Observable as source.\n   * Use this to conceal other aspects of a Unit, System, Action or Cluster except the Observable part.\n   *\n   * @returns An Observable with the value of a Unit, System, Action or Cluster.\n   *\n   * @category Common\n   */\n  asObservable(): Observable<T> {\n    const observable = new Observable<T>();\n    (observable as any).source = (this as any).source;\n    return observable;\n  }\n\n  /**\n   * To manually re-emit the last emitted value again.\n   *\n   * @triggers {@link EventReplay}\n   * @category Common\n   */\n  replay(): void {\n    this.emit(this.emittedValue);\n\n    if (this.eventsSubject?.observers.length) {\n      this.eventsSubject.next(new EventReplay(this.emittedValue));\n    }\n  }\n\n  /**\n   * Converts the value to JSON string, using `JSON.stringify`.\n   *\n   * @category Common\n   */\n  toJsonString(): string {\n    return JSON.stringify(this.rawValue());\n  }\n\n  /**\n   * Returns the {@link rawValue},\n   * JavaScript automatically invokes it when encountering an object where a primitive value is expected.\n   *\n   * @alias {@link rawValue}\n   * This method is not intended to be used by developers, use {@link rawValue} instead.\n   * It only exists to be used by JavaScript implicitly.\n   *\n   * @hidden\n   * @category Customised Object.prototype\n   */\n  valueOf(): T {\n    return this.rawValue();\n  }\n\n  /**\n   * Returns the {@link rawValue}.\n   * JavaScript automatically invokes it when `JSON.stringify` is invoked on an object.\n   *\n   * @alias {@link rawValue}\n   * This method is not intended to be used by developers, use {@link rawValue} instead.\n   * It only exists to be used by `JSON.stringify` implicitly.\n   *\n   * @hidden\n   * @category Common\n   */\n  toJSON(): T {\n    return this.rawValue();\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  protected emit(value: T = this.value()): void {\n    ++this._emitCount;\n    this.emittedValue = value;\n\n    if (this.sourceSubject !== this.futureSubject) {\n      this.sourceSubject.next(value);\n    }\n    this.futureSubject.next(value);\n  }\n\n  /**\n   * @internal please do not use.\n   */\n  private setupEvents(): void {\n    Object.defineProperty(this, 'events$', {\n      get() {\n        if (this._events) {\n          return this._events;\n        }\n\n        this.eventsSubject = new Subject<BaseEvents<T>>();\n        this._events = this.eventsSubject.asObservable();\n\n        Object.defineProperty(this, 'eventsSubject', {enumerable: false});\n        Object.defineProperty(this, '_events', {enumerable: false});\n\n        return this._events;\n      },\n      enumerable: false,\n    });\n  }\n\n  // tslint:disable\n  // Overriding inherited properties and methods from RxJS Observable.\n  // This hack is essential to reduce API surface area and avoid confusion\n  // with our own implementations like `forEvery`.\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  _isScalar: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  operator: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  lift: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  _trySubscribe: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  _subscribe: any;\n\n  /**\n   * @alias forEvery\n   * @deprecated Use {@link forEvery} instead.\n   * This `forEach` is not the usual `Array.forEach`.\n   * This `forEach` is an RxJS feature, which got inherited due to extending the Observable class,\n   * But this is not what you want, most probably you just want to iterate over the items, for that\n   * we've implemented the normal `forEach` functionality into `forEvery` method.\n   *\n   * This `forEach` is marked deprecated to prevent accidental usage, and avoid confusion.\n   * You can still use it though, if you want the RxJS feature,\n   * see {@link Observable.forEach} for usage.\n   * @hidden\n   */\n  forEach: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  static create: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  static if: any;\n\n  /**\n   * @deprecated\n   * @internal please do not use.\n   */\n  static throw: any;\n  // tslint:enable\n}\n\n/**\n * @internal please do not use.\n */\nconst MethodsNotToImplement = [\n  ...Object.getOwnPropertyNames(Observable.prototype),\n  ...Object.getOwnPropertyNames(Base.prototype),\n];\n\nObject.getOwnPropertyNames(Object.prototype).forEach(method => {\n  if (!isFunction(Object.prototype[method]) || MethodsNotToImplement.includes(method)) {\n    return;\n  }\n\n  Object.defineProperty(Base.prototype, method, {\n    value(...args) {\n      return this.rawValue()[method](...args);\n    },\n  });\n});\n"]}