Add accessibility feature

Author: AjaiKN

src/Building.test.ts

@@ -9,6 +9,7 @@ import {
   reverseConnection,
   onFloor,
 } from ".";
+import { isValidBuilding } from "./buildingValidity";
 
 const { RIGHT, LEFT, FRONT } = Direction;
 
@@ -451,4 +452,91 @@ describe("correct transition phrasing", () => {
   });
 });
 
+describe("accessibility", () => {
+  test("example with elevators", () => {
+    type MyForks = "fork1";
+    type MyStairs = "stair-a" | "stair-b" | "elevator-a";
+
+    const building = new Building<MyForks, MyStairs>([
+      // hallway 11 (on 1st floor)
+      new Hallway([
+        new Stairs(LEFT, onFloor("stair-a", 1)),
+        new Room("111"),
+        new Room("112"),
+        new Stairs(LEFT, onFloor("elevator-a", 1), "the elevator"),
+      ]),
+
+      // hallway 21 (on 2nd floor)
+      new Hallway([
+        new Stairs(LEFT, onFloor("stair-a", 2)),
+        new Room("211"),
+        new Room("212"),
+        new Fork(RIGHT, reverseConnection("fork1"), "the 22s"),
+        new Stairs(LEFT, onFloor("elevator-a", 2), "the elevator"),
+      ]),
+
+      // hallway 22 (on 2nd floor)
+      new Hallway([
+        new Room("221"),
+        new Room("222"),
+        new Stairs(LEFT, onFloor("stair-b", 2)),
+        new Fork(FRONT, "fork1", "the 21s"),
+      ]),
+
+      // hallway 31 (on 3rd floor)
+      new Hallway([
+        new Room("311", RIGHT),
+        new Stairs(LEFT, onFloor("stair-a", 3)),
+        new Room("312"),
+        new Stairs(LEFT, onFloor("elevator-a", 3), "the elevator"),
+      ]),
+
+      // hallway 32 (on 3rd floor)
+      new Hallway([
+        new Room("321"),
+        new Stairs(LEFT, onFloor("stair-b", 3)),
+        new Room("322"),
+      ]),
+    ]);
+
+    const buildingNonAccessible = building.withAllowedConnectionTypes(
+      s => !s.includes("elevator")
+    );
+
+    const buildingAccessible = building.withAllowedConnectionTypes(
+      s => !s.includes("stair")
+    );
+
+    expect(buildingNonAccessible.getDirections("111", "312"))
+      .toMatchInlineSnapshot(`
+        "Turn right out of room 111
+        Continue, then turn right into the stairs
+        Go up 2 floors of stairs
+        Turn left out of the stairs
+        Continue, then turn left into room 312"
+      `);
+
+    expect(buildingAccessible.getDirections("111", "312"))
+      .toMatchInlineSnapshot(`
+        "Turn left out of room 111
+        Continue, then turn left into the elevator
+        Go to floor 3
+        Turn right out of the elevator
+        Continue, then turn right into room 312"
+      `);
+
+    expect(isValidBuilding(buildingNonAccessible)).toEqual(
+      expect.objectContaining({ valid: true })
+    );
+
+    expect(isValidBuilding(buildingAccessible)).toEqual(
+      expect.objectContaining({
+        valid: false,
+        reason:
+          "The hallway at index 4 has no nodes (Forks or Stairs) to connect it to the rest of the building.",
+      })
+    );
+  });
+});
+
 // TODO: add tests with SimpleHallway and rooms that are nodes

src/Building.ts

@@ -59,9 +59,17 @@ export class Building<
    * @param hallways - All of the hallways in this building
    * @category Important
    */
-  constructor(readonly hallways: Hallway<ForkName, StairName>[]) {
+  constructor(
+    readonly hallways: Hallway<ForkName, StairName>[],
+    readonly allowedConnections: (
+      | ForkName
+      | StairName
+    )[] = hallways.flatMap(h => h.nodes.map(n => n.nodeId.name))
+  ) {
     const hallwayNodes = this.hallways.map(h => {
-      return h.nodes;
+      return h.nodes.filter(({ nodeId }) =>
+        allowedConnections.includes(nodeId.name)
+      );
     });
     this.graph = getGraph(hallwayNodes);
     this.roomsList = hallways
@@ -71,6 +79,17 @@ export class Building<
       .sort();
   }
 
+  withAllowedConnectionTypes(
+    allowedConnections: (ForkName | StairName)[] | ((name: string) => boolean)
+  ) {
+    return new Building(
+      this.hallways,
+      typeof allowedConnections === "function"
+        ? this.allowedConnections.filter(allowedConnections)
+        : allowedConnections
+    );
+  }
+
   /**
    * @param name - The name of the room
    * @returns An array, where the first element is the index of the hallway where
@@ -108,21 +127,22 @@ export class Building<
   /**
    *
    * @ignore
-   * @param id1 The first StairNode
-   * @param id2 The second StairNode in the same staircase
+   * TODO
    * @returns The instructions to go up/down that staircase the correct number
    * of floors
    */
-  private getStairConnectionInstruction(
-    id1: StairNode<StairName>,
-    id2: StairNode<StairName>
+  getStairConnectionInstruction(
+    stairName: StairName,
+    floor1: number,
+    floor2: number
   ): string {
-    const goingUp = id2.floor > id1.floor;
-    const numFlights = Math.abs(id1.floor - id2.floor);
+    if (stairName.includes("elevator")) {
+      return `go to floor ${floor2}\n`;
+    }
+    const upOrDown = floor2 > floor1 ? "up" : "down";
+    const numFlights = Math.abs(floor1 - floor2);
     const maybeS = numFlights > 1 ? "s" : "";
-    return `go ${
-      goingUp ? "up" : "down"
-    } ${numFlights} floor${maybeS} of stairs\n`;
+    return `go ${upOrDown} ${numFlights} floor${maybeS} of stairs\n`;
   }
 
   /**
@@ -171,9 +191,10 @@ export class Building<
     // Find IDs of the nodes (stairs or hallways) closest to these rooms
     const closestNodeFromInd = this.hallways[
       fromHallwayInd
-    ].idOfClosestNodeToIndex(fromInd);
+    ].idOfClosestNodeToIndex(fromInd, this.allowedConnections);
     const closestNodeToInd = this.hallways[toHallwayInd].idOfClosestNodeToIndex(
-      toInd
+      toInd,
+      this.allowedConnections
     );
 
     // This is to keep track of whether we entered the next hallway through a
@@ -210,7 +231,11 @@ export class Building<
             entranceWasStraight,
           }
         );
-        directions += this.getStairConnectionInstruction(prevId, nextId);
+        directions += this.getStairConnectionInstruction(
+          prevId.name,
+          prevId.floor,
+          nextId.floor
+        );
         [currentHallwayInd, currentInd] = this.getHallwayIndexAndIndexFromNode(
           nextId
         );

src/Hallway.ts

@@ -51,13 +51,15 @@ export class Hallway<ForkName extends string, StairName extends string> {
    * @returns The id of the "closest" node to the given room within this hallway
    */
   idOfClosestNodeToIndex(
-    roomInd: number
+    roomInd: number,
+    allowedConnections: (ForkName | StairName)[]
   ): ForkNode<ForkName> | StairNode<StairName> {
     let closestNodeInd: number;
     this.partList.forEach((r, currentInd) => {
       if (
         "nodeId" in r &&
         r.nodeId != null &&
+        allowedConnections.includes(r.nodeId.name) &&
         (closestNodeInd === undefined ||
           Math.abs(currentInd - roomInd) < Math.abs(closestNodeInd - roomInd))
       ) {

src/Stairs.ts

@@ -9,24 +9,19 @@ import { StairNode } from "./StairNode";
  */
 export class Stairs<StairName extends string> extends HallwayElement {
   readonly nodeId: StairNode<StairName>;
+  readonly fullName: string;
 
   constructor(
     side: Direction,
     nodeId: StairNode<StairName>,
-    public stairNumber?: string | undefined,
+    fullName: string = "the stairs",
     edgeLengthFromPreviousNodeInHallway?: number | undefined
   ) {
     super(null, side, { edgeLengthFromPreviousNodeInHallway });
+    this.fullName = fullName;
     this.nodeId = nodeId;
   }
 
-  get fullName() {
-    if (this.stairNumber) {
-      return "the " + this.stairNumber + " stairs";
-    }
-    return "the stairs";
-  }
-
   onLeave(
     forwardOrBackward: -1 | 1,
     _isBeginningOfDirections: boolean,

src/buildingValidity.ts

@@ -85,7 +85,10 @@ export function isValidBuilding<
   }
 
   // shouldn't have duplicated or unmatched nodes
-  const allNodes = b.hallways.flatMap(h => h.nodes).map(({ nodeId }) => nodeId);
+  const allNodes = b.hallways
+    .flatMap(h => h.nodes)
+    .map(({ nodeId }) => nodeId)
+    .filter(nodeId => b.allowedConnections.includes(nodeId.name));
   for (const nodeId of allNodes) {
     if (nodeId instanceof StairNode) {
       const sameStaircase = allNodes
@@ -175,7 +178,9 @@ export function isValidBuilding<
   // If there's more than 1 hallway, each hallway should have a node to
   // connect it to the rest of the hallways
   const indexOfHallwayWithNoNodes = b.hallways.findIndex(
-    h => h.nodes.length === 0
+    h =>
+      h.nodes.filter(({ nodeId }) => b.allowedConnections.includes(nodeId.name))
+        .length === 0
   );
   if (b.hallways.length > 1 && indexOfHallwayWithNoNodes !== -1) {
     return {