@vived/core 1.0.0

package/src/AppObject/AppObjectComponent.test.ts

@@ -0,0 +1,219 @@
+import { AppObject, makeAppObject } from "./AppObject";
+import { AppObjectComponent } from "./AppObjectComponent";
+import { makeAppObjectRepo } from "./AppObjectRepo";
+
+function makeTestRig() {
+  const appObjectRepo = makeAppObjectRepo();
+  const appObj = makeAppObject("appObj", appObjectRepo);
+  const appObjectComponent = new AppObjectComponent(appObj, "aComponent");
+
+  return { appObjectComponent, appObj, appObjectRepo };
+}
+
+describe("App Object Component", () => {
+  it("Sets the type", () => {
+    const { appObjectComponent } = makeTestRig();
+    expect(appObjectComponent.type).toEqual("aComponent");
+  });
+
+  it("Stores the app object", () => {
+    const { appObjectComponent, appObj } = makeTestRig();
+    expect(appObjectComponent.appObject).toEqual(appObj);
+  });
+
+  it("Adds itself to the app object", () => {
+    const { appObjectComponent, appObj } = makeTestRig();
+
+    expect(appObj.hasComponent(appObjectComponent.type)).toEqual(true);
+  });
+
+  it("Removes itself from the app object when disposed", () => {
+    const { appObjectComponent, appObj } = makeTestRig();
+
+    appObjectComponent.dispose();
+
+    expect(appObj.hasComponent(appObjectComponent.type)).toEqual(false);
+  });
+
+  it("Returns the repo", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    expect(appObjectComponent.appObjects).toEqual(appObjectRepo);
+  });
+
+  it("Forwards a warn to the App Object Repo warn", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.warn("Some warning");
+
+    expect(appObjectRepo.submitWarning).toBeCalledWith(
+      `appObj/aComponent`,
+      "Some warning"
+    );
+  });
+
+  it("Forwards a log to the App Object Repo log", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    appObjectRepo.submitLog = jest.fn();
+
+    appObjectComponent.log("Some log");
+
+    expect(appObjectRepo.submitLog).toBeCalledWith(
+      `appObj/aComponent`,
+      "Some log"
+    );
+  });
+
+  it("Forwards an error to the App Object Repo error", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    appObjectRepo.submitError = jest.fn();
+
+    appObjectComponent.error("Some error");
+
+    expect(appObjectRepo.submitError).toBeCalledWith(
+      `appObj/aComponent`,
+      "Some error"
+    );
+  });
+
+  it("Gets a singleton", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    const mockSingleton = new MockComponent(
+      appObjectRepo.getOrCreate("Some other")
+    );
+
+    const returned = appObjectComponent.getSingleton<MockComponent>(
+      MockComponent.type
+    );
+
+    expect(returned).toEqual(mockSingleton);
+  });
+
+  it("Warns by default if the singleton cannot be found", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    appObjectComponent.warn = jest.fn();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.getSingleton<MockComponent>(MockComponent.type);
+
+    expect(appObjectComponent.warn).toBeCalled();
+  });
+
+  it("Errors if the singleton cannot be found", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    appObjectComponent.error = jest.fn();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.getSingleton<MockComponent>(MockComponent.type, "ERROR");
+
+    expect(appObjectComponent.error).toBeCalled();
+  });
+
+  it("Logs if the singleton cannot be found", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    appObjectComponent.log = jest.fn();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.getSingleton<MockComponent>(MockComponent.type, "LOG");
+
+    expect(appObjectComponent.log).toBeCalled();
+  });
+
+  it("Warns if the singleton cannot be found", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    appObjectComponent.warn = jest.fn();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.getSingleton<MockComponent>(MockComponent.type, "WARN");
+
+    expect(appObjectComponent.warn).toBeCalled();
+  });
+
+  it("Gets a cached singleton", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+    const mockSingleton = new MockComponent(
+      appObjectRepo.getOrCreate("Some other")
+    );
+
+    const returned = appObjectComponent.getCachedSingleton<MockComponent>(
+      MockComponent.type
+    );
+
+    expect(returned).toEqual(mockSingleton);
+  });
+
+  it("Gets a cached singleton from the local cache", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    const spy = jest.spyOn(appObjectRepo, "getSingleton");
+
+    new MockComponent(appObjectRepo.getOrCreate("Some other"));
+
+    appObjectComponent.getCachedSingleton<MockComponent>(MockComponent.type);
+    appObjectComponent.getCachedSingleton<MockComponent>(MockComponent.type);
+    appObjectComponent.getCachedSingleton<MockComponent>(MockComponent.type);
+    appObjectComponent.getCachedSingleton<MockComponent>(MockComponent.type);
+
+    expect(spy).toBeCalledTimes(1);
+  });
+
+  it("Warns if the cached singleton cannot be found", () => {
+    const { appObjectComponent, appObjectRepo } = makeTestRig();
+
+    appObjectComponent.warn = jest.fn();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectComponent.getCachedSingleton<MockComponent>(MockComponent.type);
+
+    expect(appObjectComponent.warn).toBeCalled();
+  });
+
+  it("Gets a local component", () => {
+    const { appObjectComponent, appObjectRepo, appObj } = makeTestRig();
+
+    const b1 = new MockComponent(appObj);
+
+    new MockComponent(appObjectRepo.getOrCreate("otherAO"));
+
+    expect(
+      appObjectComponent.getCachedLocalComponent<MockComponent>(
+        MockComponent.type
+      )
+    ).toEqual(b1);
+  });
+
+  it("Caches the local component", () => {
+    const { appObjectComponent, appObj } = makeTestRig();
+
+    const spy = jest.spyOn(appObj, "getComponent");
+
+    new MockComponent(appObj);
+
+    appObjectComponent.getCachedLocalComponent<MockComponent>(
+      MockComponent.type
+    );
+    appObjectComponent.getCachedLocalComponent<MockComponent>(
+      MockComponent.type
+    );
+    appObjectComponent.getCachedLocalComponent<MockComponent>(
+      MockComponent.type
+    );
+    appObjectComponent.getCachedLocalComponent<MockComponent>(
+      MockComponent.type
+    );
+
+    expect(spy).toBeCalledTimes(1);
+  });
+});
+
+class MockComponent extends AppObjectComponent {
+  static type = "MockComponent";
+
+  constructor(appObject: AppObject) {
+    super(appObject, MockComponent.type);
+  }
+}

package/src/AppObject/AppObjectComponent.ts

@@ -0,0 +1,100 @@
+import { AppObject } from "./AppObject";
+import { AppObjectRepo } from "./AppObjectRepo";
+
+export enum AppObjectComponentType {
+  ENTITY = "Entity",
+  PM = "Presentation Manager",
+  UC = "Use Case",
+  CONTROLLER = "Controller",
+  VIEW = "View",
+  UNKNOWN = "Unknown",
+}
+
+export class AppObjectComponent {
+  readonly componentType: AppObjectComponentType = AppObjectComponentType.UNKNOWN;
+  readonly type: string;
+  readonly appObject: AppObject;
+  get appObjects(): AppObjectRepo {
+    return this.appObject.appObjectRepo;
+  }
+
+  private cachedComponents = new Map<string, AppObjectComponent>();
+  getCachedSingleton<T extends AppObjectComponent>(
+    type: string
+  ): T | undefined {
+    if (!this.cachedComponents.has(type)) {
+      const component = this.appObjects.getSingleton(type);
+      if (!component) {
+        this.warn("Unable to get cached singleton type " + type);
+      } else {
+        this.cachedComponents.set(type, component);
+      }
+    }
+
+    return this.cachedComponents.get(type) as T;
+  }
+
+  getCachedLocalComponent<T extends AppObjectComponent>(
+    type: string
+  ): T | undefined {
+    if (!this.cachedComponents.has(type)) {
+      const component = this.appObject.getComponent(type);
+
+      if (!component) {
+        this.warn("Unable to get local component of type " + type);
+      } else {
+        this.cachedComponents.set(type, component);
+      }
+    }
+
+    return this.cachedComponents.get(type) as T;
+  }
+
+  getSingleton<T extends AppObjectComponent>(
+    type: string,
+    logType: "LOG" | "WARN" | "ERROR" = "WARN"
+  ): T | undefined {
+    const comp = this.appObjects.getSingleton<T>(type);
+
+    if (!comp) {
+      const msg = "Unable to get singleton type " + type;
+      switch (logType) {
+        case "ERROR":
+          this.error(msg);
+          break;
+        case "LOG":
+          this.log(msg);
+          break;
+        case "WARN":
+          this.warn(msg);
+          break;
+      }
+    }
+
+    return comp;
+  }
+
+  dispose() {
+    if (this.appObject.getComponent(this.type) === this) {
+      this.appObject.removeComponent(this.type);
+    }
+  }
+
+  log(message: string) {
+    this.appObjects.submitLog(`${this.appObject.id}/${this.type}`, message);
+  }
+
+  warn(message: string) {
+    this.appObjects.submitWarning(`${this.appObject.id}/${this.type}`, message);
+  }
+
+  error(message: string) {
+    this.appObjects.submitError(`${this.appObject.id}/${this.type}`, message);
+  }
+
+  constructor(appObject: AppObject, type: string) {
+    this.appObject = appObject;
+    this.type = type;
+    appObject.addComponent(this);
+  }
+}

package/src/AppObject/AppObjectController.ts

@@ -0,0 +1,8 @@
+import {
+  AppObjectComponent,
+  AppObjectComponentType,
+} from "./AppObjectComponent";
+
+export class AppObjectController extends AppObjectComponent {
+  readonly componentType = AppObjectComponentType.CONTROLLER;
+}

package/src/AppObject/AppObjectEntity.test.ts

@@ -0,0 +1,151 @@
+import { AppObject, makeAppObject } from "./AppObject";
+import { AppObjectComponentType } from "./AppObjectComponent";
+import { AppObjectEntity } from "./AppObjectEntity";
+import { makeAppObjectRepo } from "./AppObjectRepo";
+
+class MockEntity extends AppObjectEntity {
+  static type = "mockEntity";
+
+  constructor(appObject: AppObject) {
+    super(appObject, MockEntity.type);
+  }
+}
+
+function makeTestRig() {
+  const appObjectRepo = makeAppObjectRepo();
+  const appObj = makeAppObject("appObj", appObjectRepo);
+  const appObjectEntity = new MockEntity(appObj);
+
+  const onChangeObserver = jest.fn();
+  appObjectEntity.addChangeObserver(onChangeObserver);
+
+  return { appObjectEntity, onChangeObserver, appObj, appObjectRepo };
+}
+
+describe("Abstract Observable Entity", () => {
+  it("Sets the type", () => {
+    const { appObjectEntity } = makeTestRig();
+    expect(appObjectEntity.type).toEqual("mockEntity");
+  });
+
+  it("Notifies on change", () => {
+    const { onChangeObserver, appObjectEntity } = makeTestRig();
+    appObjectEntity.notifyOnChange();
+
+    expect(onChangeObserver).toBeCalled();
+  });
+
+  it("Removes an on change onChangeObserver", () => {
+    const { onChangeObserver, appObjectEntity } = makeTestRig();
+    appObjectEntity.removeChangeObserver(onChangeObserver);
+    appObjectEntity.notifyOnChange();
+
+    expect(onChangeObserver).not.toBeCalled();
+  });
+
+  it("Notifies when disposed", () => {
+    const { appObjectEntity } = makeTestRig();
+    const disposeObserver = jest.fn();
+    appObjectEntity.addOnDisposeObserver(disposeObserver);
+
+    appObjectEntity.dispose();
+
+    expect(disposeObserver).toBeCalled();
+  });
+
+  it("Removes a dispose onChangeObserver", () => {
+    const { appObjectEntity } = makeTestRig();
+    const disposeObserver = jest.fn();
+    appObjectEntity.addOnDisposeObserver(disposeObserver);
+    appObjectEntity.removeOnDisposeObserver(disposeObserver);
+
+    appObjectEntity.dispose();
+    expect(disposeObserver).not.toBeCalled();
+  });
+
+  it("Clears all observers when disposed", () => {
+    const { onChangeObserver, appObjectEntity } = makeTestRig();
+    const disposeObserver = jest.fn();
+    appObjectEntity.addOnDisposeObserver(disposeObserver);
+
+    appObjectEntity.dispose();
+
+    disposeObserver.mockClear();
+    onChangeObserver.mockClear();
+
+    appObjectEntity.notifyOnChange();
+    appObjectEntity.dispose();
+
+    expect(onChangeObserver).not.toBeCalled();
+    expect(disposeObserver).not.toBeCalled();
+  });
+
+  it("Stores the app object", () => {
+    const { appObjectEntity, appObj } = makeTestRig();
+    expect(appObjectEntity.appObject).toEqual(appObj);
+  });
+
+  it("Adds itself to the app object", () => {
+    const { appObjectEntity, appObj } = makeTestRig();
+
+    expect(appObj.hasComponent(appObjectEntity.type)).toEqual(true);
+  });
+
+  it("Removes itself from the app object when disposed", () => {
+    const { appObjectEntity, appObj } = makeTestRig();
+
+    appObjectEntity.dispose();
+
+    expect(appObj.hasComponent(appObjectEntity.type)).toEqual(false);
+  });
+
+  it("Forwards notifications to the App Object observers", () => {
+    const { appObjectEntity, appObj } = makeTestRig();
+
+    const appObjObserver = jest.fn();
+    appObj.addObserver(appObjObserver);
+
+    appObjectEntity.notifyOnChange();
+
+    expect(appObjObserver).toBeCalled();
+  });
+
+  it("Stops forwarding notifications to the App Object observers when disposed", () => {
+    const { appObjectEntity, appObj } = makeTestRig();
+
+    const appObjObserver = jest.fn();
+    appObj.addObserver(appObjObserver);
+
+    appObjectEntity.dispose();
+    appObjObserver.mockClear();
+
+    appObjectEntity.notifyOnChange();
+
+    expect(appObjObserver).not.toBeCalled();
+  });
+
+  it("Returns the repo", () => {
+    const { appObjectEntity, appObjectRepo } = makeTestRig();
+    expect(appObjectEntity.appObjects).toEqual(appObjectRepo);
+  });
+
+  it("Forwards a warn to the App Object Repo warn", () => {
+    const { appObjectEntity, appObjectRepo } = makeTestRig();
+    appObjectRepo.submitWarning = jest.fn();
+
+    appObjectEntity.warn("Some warning");
+
+    expect(appObjectRepo.submitWarning).toBeCalledWith(
+      `appObj/mockEntity`,
+      "Some warning"
+    );
+  });
+
+  it("Sets Component type to Entity", () => {
+    const { appObjectEntity } = makeTestRig();
+
+    expect(appObjectEntity.componentType).toEqual(
+      AppObjectComponentType.ENTITY
+    );
+  });
+});

package/src/AppObject/AppObjectEntity.ts

@@ -0,0 +1,45 @@
+import { ObserverList } from "../Entities";
+import { AppObject } from "./AppObject";
+import { AppObjectComponent, AppObjectComponentType } from "./AppObjectComponent";
+
+export type AppObjectEntityObserver = () => void;
+
+export class AppObjectEntity extends AppObjectComponent {
+  readonly componentType = AppObjectComponentType.ENTITY;
+  
+  private onDisposeObserverList = new ObserverList<void>();
+  addOnDisposeObserver = (observer: AppObjectEntityObserver) => {
+    this.onDisposeObserverList.add(observer);
+  };
+  removeOnDisposeObserver = (observer: AppObjectEntityObserver): void => {
+    this.onDisposeObserverList.remove(observer);
+  };
+
+  private onChangeObserverList = new ObserverList<void>();
+  addChangeObserver = (observer: AppObjectEntityObserver): void => {
+    this.onChangeObserverList.add(observer);
+  };
+  removeChangeObserver = (observer: AppObjectEntityObserver): void => {
+    this.onChangeObserverList.remove(observer);
+  };
+
+  notifyOnChange = () => {
+    this.onChangeObserverList.notify();
+  };
+
+  dispose() {
+    this.removeChangeObserver(this.appObject.notify);
+
+    this.onDisposeObserverList.notify();
+    this.onChangeObserverList.clear();
+    this.onDisposeObserverList.clear();
+
+    super.dispose();
+  }
+
+  constructor(appObject: AppObject, type: string) {
+    super(appObject, type)
+    
+    this.addChangeObserver(appObject.notify);
+  }
+}