@vived/core 1.0.0

package/src/AppObject/AppObjectEntityRepo.test.ts

@@ -0,0 +1,211 @@
+import { AppObject, makeAppObject } from "./AppObject";
+import { AppObjectEntity } from "./AppObjectEntity";
+import { AppObjectEntityRepo } from "./AppObjectEntityRepo";
+import { makeAppObjectRepo } from "./AppObjectRepo";
+
+class MockAppEntity extends AppObjectEntity {
+  static type: string = "mockEntity";
+
+  constructor(appObject: AppObject) {
+    super(appObject, MockAppEntity.type)
+  }
+}
+
+class MockEntityRepoImp extends AppObjectEntityRepo<MockAppEntity> {
+  static type: string = "Mock Repo";
+
+  makeEntity(appObj: AppObject): MockAppEntity {
+    return new MockAppEntity(appObj);
+  }
+
+  constructor(appObject: AppObject) {
+    super(appObject, MockAppEntity.type)
+  }
+}
+
+function makeTestRig() {
+  const appObjects = makeAppObjectRepo();
+  const repoAppObj = makeAppObject("repo", appObjects);
+  const repo = new MockEntityRepoImp(repoAppObj);
+  
+  const appObj = makeAppObject("appObjID", appObjects);
+  const observer = jest.fn();
+  repo.addChangeObserver(observer);
+
+  return { repo, observer, appObj };
+}
+
+describe("Observable Entity Repo", () => {
+  it("Allows an entity to be added", () => {
+    const { repo, appObj } = makeTestRig();
+    const entity = new MockAppEntity(appObj);
+
+    expect(repo.hasForAppObject("appObjID")).toEqual(false);
+
+    repo.add(entity);
+
+    expect(repo.hasForAppObject("appObjID")).toEqual(true);
+  });
+
+  it("Notifies when an entity is added", () => {
+    const { repo, observer, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+    repo.add(entity);
+
+    expect(observer).toBeCalled();
+  });
+
+  it("Forwards notification from an added entity", () => {
+    const { repo, observer, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+    repo.add(entity);
+
+    observer.mockClear();
+
+    entity.notifyOnChange();
+
+    expect(observer).toBeCalled();
+  });
+
+  it("Stops notifying if adding an entity replaces and exisitng entity", () => {
+    const { repo, observer, appObj } = makeTestRig();
+
+    console.warn = jest.fn(); // Replacing warns. This keeps the console clean
+
+    const original =new MockAppEntity(appObj);
+    repo.add(original);
+
+    const replacement =new MockAppEntity(appObj);
+    repo.add(replacement);
+    observer.mockClear();
+
+    original.notifyOnChange();
+
+    expect(observer).not.toBeCalled();
+  });
+
+  it("Removes an entity", () => {
+    const { repo, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+
+    repo.add(entity);
+
+    expect(repo.hasForAppObject("appObjID")).toEqual(true);
+
+    repo.removeForAppObject("appObjID");
+
+    expect(repo.hasForAppObject("appObjID")).toEqual(false);
+  });
+
+  it("Notifies if an entity is removed", () => {
+    const { repo, observer, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+
+    repo.add(entity);
+    observer.mockClear();
+
+    repo.removeForAppObject("appObjID");
+
+    expect(observer).toBeCalled();
+  });
+
+  it("Does not notifyOnChange if the entity to be removed cannot be found", () => {
+    const { repo, observer } = makeTestRig();
+
+    repo.removeForAppObject("someId");
+    repo.removeForAppObject("someId");
+    repo.removeForAppObject("someId");
+
+    expect(observer).not.toBeCalled();
+  });
+
+  it("Stops observing a removed entity", () => {
+    const { repo, observer, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+
+    repo.add(entity);
+    repo.removeForAppObject("appObjID");
+
+    observer.mockClear();
+
+    entity.notifyOnChange();
+
+    expect(observer).not.toBeCalled();
+  });
+
+  it("Gets an entity", () => {
+    const { repo, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+    repo.add(entity);
+
+    expect(repo.getForAppObject("appObjID")).toEqual(entity);
+  });
+
+  it("Gets all entities", () => {
+    const { repo, appObj } = makeTestRig();
+    const entity =new MockAppEntity(appObj);
+    repo.add(entity);
+
+    expect(repo.getAll()).toEqual([entity]);
+  });
+
+  it("Returns undefined for an unknown entity", () => {
+    const { repo } = makeTestRig();
+
+    expect(repo.getForAppObject("unknownID")).toBeUndefined();
+  });
+
+
+  it("Supports notifying an observer when an entity is added", () => {
+    const { repo, appObj } = makeTestRig();
+
+    const addEntityObserver = jest.fn();
+    repo.addEntityAddedObserver(addEntityObserver);
+
+    const ent =new MockAppEntity(appObj);
+    repo.add(ent);
+
+    expect(addEntityObserver).toBeCalledWith(ent);
+  });
+
+  it("Add entity observer can be removed", () => {
+    const { repo, appObj } = makeTestRig();
+
+    const addEntityObserver = jest.fn();
+    repo.addEntityAddedObserver(addEntityObserver);
+    repo.removeEntityAddedObserver(addEntityObserver);
+
+    const ent =new MockAppEntity(appObj);
+    repo.add(ent);
+
+    expect(addEntityObserver).not.toBeCalled();
+  });
+
+  it("Supports notifying an observer when an entity is removed", () => {
+    const { repo, appObj } = makeTestRig();
+
+    const removeEntityObserver = jest.fn();
+    repo.addEntityRemovedObserver(removeEntityObserver);
+
+    const ent =new MockAppEntity(appObj);
+    repo.add(ent);
+
+    repo.removeForAppObject("appObjID");
+
+    expect(removeEntityObserver).toBeCalledWith(ent);
+  });
+
+  it("Remove entity observer can be removed", () => {
+    const { repo, appObj } = makeTestRig();
+
+    const removeEntityObserver = jest.fn();
+    repo.addEntityRemovedObserver(removeEntityObserver);
+    repo.removeEntityRemovedObserver(removeEntityObserver);
+
+    const ent =new MockAppEntity(appObj);
+    repo.add(ent);
+    repo.removeForAppObject("appObjID");
+
+    expect(removeEntityObserver).not.toBeCalled();
+  });
+});

package/src/AppObject/AppObjectEntityRepo.ts

@@ -0,0 +1,61 @@
+import { ObserverList } from "../Entities";
+import { AppObjectEntity } from "./AppObjectEntity";
+
+export class AppObjectEntityRepo<
+  T extends AppObjectEntity
+> extends AppObjectEntity {
+
+  private entityLookup = new Map<string, T>();
+
+  private onEntityAddedObservers = new ObserverList<T>();
+  addEntityAddedObserver = (observer: (addedEntity: T) => void) => {
+    this.onEntityAddedObservers.add(observer);
+  };
+  removeEntityAddedObserver = (observer: (addedEntity: T) => void): void => {
+    this.onEntityAddedObservers.remove(observer);
+  };
+
+  private onEntityRemovedObservers = new ObserverList<T>();
+  addEntityRemovedObserver = (observer: (removedEntity: T) => void) => {
+    this.onEntityRemovedObservers.add(observer);
+  };
+  removeEntityRemovedObserver = (
+    observer: (removedEntity: T) => void
+  ): void => {
+    this.onEntityRemovedObservers.remove(observer);
+  };
+
+  hasForAppObject = (appObjectID: string): boolean => {
+    return this.entityLookup.has(appObjectID);
+  };
+
+  add(entity: T) {
+    const existing = this.entityLookup.get(entity.appObject.id);
+    if (existing) {
+      existing.removeChangeObserver(this.notifyOnChange);
+    }
+
+    this.entityLookup.set(entity.appObject.id, entity);
+    entity.addChangeObserver(this.notifyOnChange);
+    this.notifyOnChange();
+    this.onEntityAddedObservers.notify(entity);
+  };
+
+  removeForAppObject = (id: string) => {
+    const existing = this.entityLookup.get(id);
+    if (!existing) return;
+
+    this.entityLookup.delete(id);
+    existing.removeChangeObserver(this.notifyOnChange);
+    this.notifyOnChange();
+    this.onEntityRemovedObservers.notify(existing);
+  };
+
+  getForAppObject = (appObjectID: string): T | undefined => {
+    return this.entityLookup.get(appObjectID);
+  };
+
+  getAll = (): T[] => {
+    return Array.from(this.entityLookup.values());
+  };
+}

package/src/AppObject/AppObjectPM.test.ts

@@ -0,0 +1,152 @@
+import { AppObject } from "./AppObject";
+import { AppObjectComponentType } from "./AppObjectComponent";
+import { AppObjectPM } from "./AppObjectPM";
+import { makeAppObjectRepo } from "./AppObjectRepo";
+
+interface MockVM {
+  val: number;
+}
+
+class MockPM extends AppObjectPM<MockVM> {
+  static readonly type = "MockPM";
+
+  readonly defaultVM = { val: 0 };
+  get currentVM(): MockVM {
+    return { val: 5 };
+  }
+
+  vmsAreEqual(a: MockVM, b: MockVM): boolean {
+    return a.val === b.val;
+  }
+
+  constructor(appObj: AppObject) {
+    super(appObj, MockPM.type);
+  }
+}
+
+function makeTestRig() {
+  const appObjects = makeAppObjectRepo();
+  const appObj = appObjects.getOrCreate("appObj");
+
+  return { appObj, appObjects };
+}
+
+describe("App Object PM", () => {
+  it("Initializes with the last VM if it has been set", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+    const view = jest.fn();
+
+    pm.doUpdateView({ val: 6 });
+
+    pm.addView(view);
+
+    expect(view).toBeCalledWith({ val: 6 });
+  });
+
+  it("Adds a view but does not call it if no VM has been set", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+    const view = jest.fn();
+
+    pm.addView(view);
+
+    expect(view).not.toBeCalled();
+  });
+
+  it("Doesn't notify if the vms are equal", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+    const view = jest.fn();
+
+    pm.doUpdateView({ val: 6 });
+    pm.addView(view);
+
+    view.mockClear();
+
+    pm.doUpdateView({ val: 6 });
+    pm.doUpdateView({ val: 6 });
+    pm.doUpdateView({ val: 6 });
+
+    expect(view).not.toBeCalled();
+  });
+
+  it("Removes a view", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+    const view = jest.fn();
+
+    pm.addView(view);
+
+    view.mockClear();
+
+    pm.removeView(view);
+
+    pm.doUpdateView({ val: 10 });
+
+    expect(view).not.toBeCalled();
+  });
+
+  it("Can be disposed", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+    const view = jest.fn();
+
+    pm.addView(view);
+    view.mockClear();
+
+    pm.dispose();
+
+    pm.doUpdateView({ val: 10 });
+
+    expect(view).not.toBeCalled();
+  });
+
+  it("Adds itself to the App Object", () => {
+    const { appObj } = makeTestRig();
+
+    expect(appObj.hasComponent(MockPM.type)).toEqual(false);
+
+    const pm = new MockPM(appObj);
+
+    expect(appObj.hasComponent(MockPM.type)).toEqual(true);
+  });
+
+  it("Removes itself from the App Object when disposed", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+
+    expect(appObj.hasComponent(MockPM.type)).toEqual(true);
+
+    pm.dispose();
+
+    expect(appObj.hasComponent(MockPM.type)).toEqual(false);
+  });
+
+  it("Returns the repo", () => {
+    const { appObj, appObjects } = makeTestRig();
+
+    const pm = new MockPM(appObj);
+    expect(pm.appObjects).toEqual(appObjects);
+  });
+
+  it("Forwards a warn to the App Object Repo warn", () => {
+    const { appObj, appObjects } = makeTestRig();
+    appObjects.submitWarning = jest.fn();
+
+    const pm = new MockPM(appObj);
+    pm.warn("Some warning");
+
+    expect(appObjects.submitWarning).toBeCalledWith(
+      `appObj/MockPM`,
+      "Some warning"
+    );
+  });
+
+  it("Sets Component type to PM", () => {
+    const { appObj } = makeTestRig();
+    const pm = new MockPM(appObj);
+
+    expect(pm.componentType).toEqual(AppObjectComponentType.PM);
+  });
+});

package/src/AppObject/AppObjectPM.ts

@@ -0,0 +1,43 @@
+import { ObserverList } from "../Entities";
+import { AppObjectComponent, AppObjectComponentType } from "./AppObjectComponent";
+
+export abstract class AppObjectPM<T> extends AppObjectComponent {
+  readonly componentType = AppObjectComponentType.PM;
+  abstract vmsAreEqual(a: T, b: T): boolean;
+
+  private _lastVM?: T;
+  get lastVM(): T | undefined {
+    return this._lastVM;
+  }
+
+  private observerList = new ObserverList<T>();
+
+  addView(updateView: (vm: T) => void): void {
+    this.observerList.add(updateView);
+
+    if (this._lastVM !== undefined) {
+      updateView(this._lastVM);
+    }
+  }
+
+  removeView(updateView: (vm: T) => void): void {
+    this.observerList.remove(updateView);
+  }
+
+  doUpdateView(vm: T) {
+    if (this._lastVM && this.vmsAreEqual(this._lastVM, vm)) {
+      return;
+    }
+
+    this._lastVM = vm;
+    this.observerList.notify(vm);
+  }
+
+  dispose() {
+    this.observerList.clear();
+    if (this.appObject.getComponent(this.type) === this) {
+      this.appObject.removeComponent(this.type);
+    }
+    super.dispose();
+  }
+}