@vived/core 1.0.0

package/src/Entities/MemoizedBoolean.ts

@@ -0,0 +1,23 @@
+export class MemoizedBoolean {
+  private _val: boolean;
+  get val(): boolean {
+    return this._val;
+  }
+  set val(b: boolean) {
+    if (this._val === b) return;
+
+    this._val = b;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: boolean) {
+    this._val = val;
+  }
+
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: boolean, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedColor.test.ts

@@ -0,0 +1,39 @@
+import { Color } from "../ValueObjects";
+import { MemoizedColor } from "./MemoizedColor";
+
+test("Initial value is stored", () => {
+  const initialColor = Color.RGBA(5, 6, 7, 8);
+  const memoizedVector = new MemoizedColor(initialColor, jest.fn());
+  expect(memoizedVector.val).toEqual(Color.RGBA(5, 6, 7, 8));
+});
+
+test("Callback is called when the val changes", () => {
+  const cb = jest.fn();
+  const initialColor = Color.RGBA(5, 6, 7, 8);
+  const memoizedQuat = new MemoizedColor(initialColor, cb);
+
+  memoizedQuat.val = Color.RGBA(8, 9, 10, 11);
+
+  expect(cb).toBeCalled();
+});
+
+test("Callback is called only when the val changes", () => {
+  const cb = jest.fn();
+  const initialColor = Color.RGBA(5, 6, 7, 8);
+  const memoizedQuat = new MemoizedColor(initialColor, cb);
+
+  memoizedQuat.val = Color.RGBA(5, 6, 7, 8);
+  memoizedQuat.val = Color.RGBA(5, 6, 7, 8);
+  memoizedQuat.val = Color.RGBA(5, 6, 7, 8);
+
+  expect(cb).not.toBeCalled();
+});
+
+test("Setting the value quietly should not notify", () => {
+  const cb = jest.fn();
+  const memoizedQuat = new MemoizedColor(Color.RGBA(5, 6, 7, 8), cb);
+
+  memoizedQuat.setValQuietly(Color.RGBA(0, 0, 0, 0));
+
+  expect(cb).not.toBeCalled();
+});

package/src/Entities/MemoizedColor.ts

@@ -0,0 +1,27 @@
+import { Color } from "../ValueObjects";
+
+export class MemoizedColor {
+  private _val: Color;
+
+  get val(): Color {
+    return this._val;
+  }
+
+  set val(v: Color) {
+    if (Color.Equal(v, this._val)) return;
+
+    this._val = v;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: Color) {
+    this._val = val;
+  }
+
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: Color, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedNumber.test.ts

@@ -0,0 +1,37 @@
+import { MemoizedNumber } from "./MemoizedNumber";
+
+test("Initial value is stored", ()=>{
+  const memoizedNumber = new MemoizedNumber(33, jest.fn());
+  expect(memoizedNumber.val).toEqual(33);
+})
+
+test("Callback is called when something changes", ()=>{
+  const cb = jest.fn();
+  const memoizedNumber = new MemoizedNumber(33, cb);
+
+  expect(cb).not.toBeCalled();
+
+  memoizedNumber.val = 55;
+
+  expect(cb).toBeCalled();
+})
+
+test("CB is only called when something has changed", ()=>{
+  const cb = jest.fn();
+  const memoizedNumber = new MemoizedNumber(33, cb);
+
+  memoizedNumber.val = 33;
+  memoizedNumber.val = 33;
+  memoizedNumber.val = 33;
+
+  expect(cb).not.toBeCalled();
+})
+
+test("Setting the value quietly should not notify", ()=>{
+  const cb = jest.fn();
+  const memoizedBoolean = new MemoizedNumber(2, cb);
+
+  memoizedBoolean.setValQuietly(3);
+
+  expect(cb).not.toBeCalled();
+})

package/src/Entities/MemoizedNumber.ts

@@ -0,0 +1,23 @@
+export class MemoizedNumber {
+  private _val: number;
+  get val(): number {
+    return this._val;
+  }
+  set val(b: number) {
+    if (this._val === b) return;
+
+    this._val = b;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: number) {
+    this._val = val;
+  }
+  
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: number, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedQuaternion.test.ts

@@ -0,0 +1,39 @@
+import { Quaternion } from "../ValueObjects";
+import { MemoizedQuaternion } from "./MemoizedQuaternion";
+
+test("Initial value is stored", () => {
+  const initialQuat = new Quaternion(5, 6, 7, 8);
+  const memoizedVector = new MemoizedQuaternion(initialQuat, jest.fn());
+  expect(memoizedVector.val).toEqual(new Quaternion(5, 6, 7, 8));
+});
+
+test("Callback is called when the val changes", () => {
+  const cb = jest.fn();
+  const initialQuat = new Quaternion(5, 6, 7, 8);
+  const memoizedQuat = new MemoizedQuaternion(initialQuat, cb);
+
+  memoizedQuat.val = new Quaternion(8, 9, 10, 11);
+
+  expect(cb).toBeCalled();
+});
+
+test("Callback is called only when the val changes", () => {
+  const cb = jest.fn();
+  const initialQuat = new Quaternion(5, 6, 7, 8);
+  const memoizedQuat = new MemoizedQuaternion(initialQuat, cb);
+
+  memoizedQuat.val = new Quaternion(5, 6, 7, 8);
+  memoizedQuat.val = new Quaternion(5, 6, 7, 8);
+  memoizedQuat.val = new Quaternion(5, 6, 7, 8);
+
+  expect(cb).not.toBeCalled();
+});
+
+test("Setting the value quietly should not notify", () => {
+  const cb = jest.fn();
+  const memoizedQuat = new MemoizedQuaternion(Quaternion.Identity(), cb);
+
+  memoizedQuat.setValQuietly(Quaternion.Identity());
+
+  expect(cb).not.toBeCalled();
+});

package/src/Entities/MemoizedQuaternion.ts

@@ -0,0 +1,27 @@
+import { Quaternion } from "../ValueObjects";
+
+export class MemoizedQuaternion {
+  private _val: Quaternion;
+
+  get val(): Quaternion {
+    return this._val;
+  }
+
+  set val(v: Quaternion) {
+    if (Quaternion.Equal(v, this._val)) return;
+
+    this._val = v;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: Quaternion) {
+    this._val = val;
+  }
+
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: Quaternion, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedString.test.ts

@@ -0,0 +1,37 @@
+import { MemoizedString } from "./MemoizedString";
+
+test("Initial value is stored", ()=>{
+  const memoizedNumber = new MemoizedString("string1", jest.fn());
+  expect(memoizedNumber.val).toEqual("string1");
+})
+
+test("Callback is called when something changes", ()=>{
+  const cb = jest.fn();
+  const memoizedNumber = new MemoizedString("string1", cb);
+
+  expect(cb).not.toBeCalled();
+
+  memoizedNumber.val = "string2";
+
+  expect(cb).toBeCalled();
+})
+
+test("CB is only called when something has changed", ()=>{
+  const cb = jest.fn();
+  const memoizedNumber = new MemoizedString("string1", cb);
+
+  memoizedNumber.val = "string1";
+  memoizedNumber.val = "string1";
+  memoizedNumber.val = "string1";
+
+  expect(cb).not.toBeCalled();
+})
+
+test("Setting the value quietly should not notify", ()=>{
+  const cb = jest.fn();
+  const memoizedBoolean = new MemoizedString("string1", cb);
+
+  memoizedBoolean.setValQuietly("string2");
+
+  expect(cb).not.toBeCalled();
+})

package/src/Entities/MemoizedString.ts

@@ -0,0 +1,23 @@
+export class MemoizedString {
+  private _val: string;
+  get val(): string {
+    return this._val;
+  }
+  set val(b: string) {
+    if (this._val === b) return;
+
+    this._val = b;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: string) {
+    this._val = val;
+  }
+   
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: string, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedVector2.test.ts

@@ -0,0 +1,39 @@
+import { Vector2 } from "../ValueObjects";
+import { MemoizedVector2 } from "./MemoizedVector2";
+
+test("Initial value is stored", () => {
+  const initialVec = new Vector2(5, 6);
+  const memoizedVector = new MemoizedVector2(initialVec, jest.fn());
+  expect(memoizedVector.val).toEqual(new Vector2(5, 6));
+});
+
+test("Callback is called when the val changes", () => {
+  const cb = jest.fn();
+  const initialVec = new Vector2(5, 6);
+  const memoizedVector = new MemoizedVector2(initialVec, cb);
+
+  memoizedVector.val = new Vector2(8, 9);
+
+  expect(cb).toBeCalled();
+});
+
+test("Callback is called only when the val changes", () => {
+  const cb = jest.fn();
+  const initialVec = new Vector2(5, 6);
+  const memoizedVector = new MemoizedVector2(initialVec, cb);
+
+  memoizedVector.val = new Vector2(5, 6);
+  memoizedVector.val = new Vector2(5, 6);
+  memoizedVector.val = new Vector2(5, 6);
+
+  expect(cb).not.toBeCalled();
+});
+
+test("Setting the value quietly should not notify", () => {
+  const cb = jest.fn();
+  const memoizedBoolean = new MemoizedVector2(Vector2.One(), cb);
+
+  memoizedBoolean.setValQuietly(Vector2.Zero());
+
+  expect(cb).not.toBeCalled();
+});

package/src/Entities/MemoizedVector2.ts

@@ -0,0 +1,27 @@
+import { Vector2 } from "../ValueObjects";
+
+export class MemoizedVector2 {
+  private _val: Vector2;
+
+  get val(): Vector2 {
+    return this._val;
+  }
+
+  set val(v: Vector2) {
+    if (Vector2.Equal(v, this._val)) return;
+
+    this._val = v;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: Vector2) {
+    this._val = val;
+  }
+
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: Vector2, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/MemoizedVector3.test.ts

@@ -0,0 +1,39 @@
+import { Vector3 } from "../ValueObjects";
+import { MemoizedVector3 } from "./MemoizedVector3";
+
+test("Initial value is stored", () => {
+  const initialVec = new Vector3(5, 6, 7);
+  const memoizedVector = new MemoizedVector3(initialVec, jest.fn());
+  expect(memoizedVector.val).toEqual(new Vector3(5, 6, 7));
+});
+
+test("Callback is called when the val changes", () => {
+  const cb = jest.fn();
+  const initialVec = new Vector3(5, 6, 7);
+  const memoizedVector = new MemoizedVector3(initialVec, cb);
+
+  memoizedVector.val = new Vector3(8, 9, 10);
+
+  expect(cb).toBeCalled();
+});
+
+test("Callback is called only when the val changes", () => {
+  const cb = jest.fn();
+  const initialVec = new Vector3(5, 6, 7);
+  const memoizedVector = new MemoizedVector3(initialVec, cb);
+
+  memoizedVector.val = new Vector3(5, 6, 7);
+  memoizedVector.val = new Vector3(5, 6, 7);
+  memoizedVector.val = new Vector3(5, 6, 7);
+
+  expect(cb).not.toBeCalled();
+});
+
+test("Setting the value quietly should not notify", () => {
+  const cb = jest.fn();
+  const memoizedBoolean = new MemoizedVector3(Vector3.One(), cb);
+
+  memoizedBoolean.setValQuietly(Vector3.Zero());
+
+  expect(cb).not.toBeCalled();
+});

package/src/Entities/MemoizedVector3.ts

@@ -0,0 +1,27 @@
+import { Vector3 } from "../ValueObjects";
+
+export class MemoizedVector3 {
+  private _val: Vector3;
+
+  get val(): Vector3 {
+    return this._val;
+  }
+
+  set val(v: Vector3) {
+    if (Vector3.Equal(v, this._val)) return;
+
+    this._val = v;
+    this.onChangeCallback();
+  }
+
+  public setValQuietly(val: Vector3) {
+    this._val = val;
+  }
+
+  private onChangeCallback: () => void;
+
+  constructor(initialValue: Vector3, onChangeCallback: () => void) {
+    this._val = initialValue;
+    this.onChangeCallback = onChangeCallback;
+  }
+}

package/src/Entities/ObservableEntity.test.ts

@@ -0,0 +1,28 @@
+import { ObservableEntity } from "./ObservableEntity";
+
+class ObservableEntityImp extends ObservableEntity {}
+
+function makeTestRig() {
+  const observableEntity = new ObservableEntityImp();
+  const observer = jest.fn();
+  observableEntity.addObserver(observer);
+
+  return { observableEntity, observer };
+}
+
+describe("Abstract Observable Entity", () => {
+  it("Notifies", () => {
+    const { observer, observableEntity } = makeTestRig();
+    observableEntity.notify();
+
+    expect(observer).toBeCalled();
+  });
+
+  it("Removes an observer", () => {
+    const { observer, observableEntity } = makeTestRig();
+    observableEntity.removeObserver(observer);
+    observableEntity.notify();
+
+    expect(observer).not.toBeCalled();
+  });
+});

package/src/Entities/ObservableEntity.ts

@@ -0,0 +1,17 @@
+import { ObserverList } from "./ObserverList";
+
+export type EntityObserver = () => void;
+
+export abstract class ObservableEntity {
+  private observerList = new ObserverList<void>();
+
+  addObserver = (observer: EntityObserver): void => {
+    this.observerList.add(observer);
+  };
+  removeObserver = (observer: EntityObserver): void => {
+    this.observerList.remove(observer);
+  };
+  notify = () => {
+    this.observerList.notify();
+  };
+}

package/src/Entities/ObserverList.test.ts

@@ -0,0 +1,61 @@
+import { ObserverList } from "./ObserverList";
+
+test("An observer that recieves nothing", () => {
+  const observers = new ObserverList<void>();
+  const obs = jest.fn();
+
+  observers.add(obs);
+  observers.notify();
+
+  expect(obs).toBeCalled();
+});
+
+test("An observer that recieves a string", () => {
+  const observers = new ObserverList<string>();
+  const obs = jest.fn();
+
+  observers.add(obs);
+  observers.notify("!yolo");
+
+  expect(obs).toBeCalledWith("!yolo");
+});
+
+test("An observer that recieves a number", () => {
+  const observers = new ObserverList<number>();
+  const obs = jest.fn();
+
+  observers.add(obs);
+
+  observers.notify(55);
+
+  expect(obs).toBeCalledWith(55);
+});
+
+test("Observer can be removed", () => {
+  const observers = new ObserverList<void>();
+  const obs = jest.fn();
+
+  observers.add(obs);
+  observers.notify();
+
+  expect(obs).toBeCalled();
+
+  obs.mockClear();
+  observers.remove(obs);
+  observers.notify();
+
+  expect(obs).not.toBeCalled();
+});
+
+test("Clearing the oberver list", ()=>{
+  const observers = new ObserverList<void>();
+  const obs = jest.fn();
+
+  observers.add(obs);
+
+  observers.clear();
+
+  observers.notify();
+
+  expect(obs).not.toBeCalled();
+})

package/src/Entities/ObserverList.ts

@@ -0,0 +1,24 @@
+export class ObserverList<T> {
+  private observers: ((msg: T) => void)[] = [];
+
+  public notify = (msg: T) => {
+    this.observers.forEach((obs) => {
+      obs(msg);
+    });
+  }
+
+  public add = (obs: (msg: T) => void) => {
+    this.observers.push(obs);
+  }
+
+  public remove = (obs: (msg: T) => void) => {
+    const index = this.observers.indexOf(obs);
+    if (index >= 0) {
+      this.observers.splice(index, 1);
+    }
+  }
+
+  public clear = () => {
+    this.observers = [];
+  }
+}

package/src/Entities/index.ts

@@ -0,0 +1,10 @@
+export * from "./ObservableEntity";
+export * from "./ObserverList";
+export * from "./MemoizedAngle";
+export * from "./MemoizedBoolean";
+export * from "./MemoizedColor";
+export * from "./MemoizedNumber";
+export * from "./MemoizedQuaternion";
+export * from "./MemoizedString";
+export * from "./MemoizedVector2";
+export * from "./MemoizedVector3";

package/src/Types/AppBoundary.ts

@@ -0,0 +1,13 @@
+export type Handler = (request: Request) => void;
+
+export interface Request {
+  type: string;
+  version: number;
+  payload?: unknown;
+}
+
+// tslint:disable-next-line: class-name
+export interface VIVEDApp_3 {
+  mount(hostRequestHandler: Handler): Handler;
+  mountDev(container: HTMLElement): void;
+}

package/src/Types/EaseFn.ts

@@ -0,0 +1 @@
+export type EaseFn = (p: number) => number;

package/src/Types/PmAdapter.ts

@@ -0,0 +1,15 @@
+import { AppObjectRepo } from "../AppObject";
+
+export interface PmAdapter<VM> {
+  defaultVM: VM;
+  subscribe(
+    id: string,
+    appObjects: AppObjectRepo,
+    setVM: (vm: VM) => void
+  ): void;
+  unsubscribe(
+    id: string,
+    appObjects: AppObjectRepo,
+    setVM: (vm: VM) => void
+  ): void;
+}

package/src/Types/SingletonPmAdapter.ts

@@ -0,0 +1,7 @@
+import { AppObjectRepo } from "../AppObject";
+
+export interface SingletonPmAdapter<VM> {
+  defaultVM: VM;
+  subscribe(appObjects: AppObjectRepo, setVM: (vm: VM) => void): void;
+  unsubscribe(appObjects: AppObjectRepo, setVM: (vm: VM) => void): void;
+}

package/src/Types/index.ts

@@ -0,0 +1,4 @@
+export * from "./AppBoundary";
+export * from "./EaseFn";
+export * from "./PmAdapter";
+export * from "./SingletonPmAdapter";

package/src/ValueObjects/Angle.test.ts

@@ -0,0 +1,30 @@
+import { Angle } from "./Angle";
+describe("Angle Value Object", () => {
+  it("Creates an angle from degrees", () => {
+    const ang = Angle.FromDegrees(125);
+    expect(ang.degrees).toEqual(125);
+  });
+
+  it("Creates an angle from degrees", () => {
+    const ang = Angle.FromRadians(1.25);
+    expect(ang.radians).toEqual(1.25);
+  });
+
+  it("Converts from degrees and radians", () => {
+    const ang = Angle.FromDegrees(125);
+    expect(ang.radians).toBeCloseTo(2.18166);
+  });
+
+  it("Converts from radians to degrees", () => {
+    const ang = Angle.FromRadians(1.25);
+    expect(ang.degrees).toBeCloseTo(71.61972);
+  });
+
+  it("Checks for closeness", ()=>{
+    const ang1 = Angle.FromDegrees(1.555);
+    const ang2 = Angle.FromDegrees(1.556);
+
+    expect(Angle.Close(ang1, ang2, 0.0011)).toEqual(true);
+    expect(Angle.Close(ang1, ang2, 0.001)).toEqual(false);
+  })
+});