Add full-width canvas, and document PrimeMath

Gruntfile.js

@@ -48,7 +48,7 @@ module.exports = grunt => {
             },
             html: {
                 files: ["src/main/**/*.html"],
-                tasks: ["copy:html"],
+                tasks: ["copy:html", "replace:dev"],
             },
             ts: {
                 files: ["src/main/**/*.ts"],

package.json

@@ -24,9 +24,9 @@
         "grunt-focus": "^1.0.0",
         "grunt-text-replace": "^0.4.0",
         "grunt-webpack": "^5.0.0",
-        "ts-loader": "^9.2.6",
-        "typescript": "^4.5.5",
-        "webpack": "^5.69.1",
+        "ts-loader": "^9.2.8",
+        "typescript": "^4.6.3",
+        "webpack": "^5.72.0",
         "webpack-cli": "^4.9.2"
     }
 }

src/main/css/main.css

@@ -0,0 +1,3 @@
+#canvasContainer {
+    margin: 2em;
+}

src/main/index.html

@@ -46,16 +46,13 @@
                     <input type="number" id="gridScale" min="1" value="15" />
                 </form>
             </div>
+        </section>
 
-            <div class="row">
-                <div class="column">
-                    <!-- Canvas -->
-                    <div id="canvasContainer">
-                        <canvas id="canvas" class="invisible" width="1" height="1">
-                            Your browser must support the &lt;canvas&gt; element to run this game.
-                        </canvas>
-                    </div>
-                </div>
+        <section>  <!-- No `container` class, to allow use of whole width -->
+            <div id="canvasContainer">
+                <canvas id="canvas" class="invisible" width="1" height="1">
+                    Your browser must support the &lt;canvas&gt; element to run this game.
+                </canvas>
             </div>
         </section>
     </div>

src/main/js/PrimeMath.ts

@@ -1,17 +1,50 @@
+/**
+ * Exposes maths functions for prime numbers.
+ */
 export interface PrimeMath {
+    /**
+     * Checks a number for primality.
+     *
+     * @param n the number to check for primality
+     * @return `true` if and only if `n` is prime
+     */
     isPrime(n: number): boolean
 
+    /**
+     * Decomposes `n` into its prime factors.
+     *
+     * @param n the number to decompose
+     * @return the array of prime factors of `n`
+     */
     decompose(n: number): number[]
 }
 
+/**
+ * Simple implementation of `PrimeMath`.
+ */
 export class SimplePrimeMath implements PrimeMath {
+    /**
+     * The singleton instance.
+     *
+     * @private
+     */
     private static instance: SimplePrimeMath;
 
 
+    /**
+     * Constructs a new `SimplePrimeMath`.
+     *
+     * @private
+     */
     private constructor() {
         // Do nothing
     }
 
+    /**
+     * Returns the singleton instance.
+     *
+     * @return the singleton instance
+     */
     public static getInstance(): SimplePrimeMath {
         if (!SimplePrimeMath.instance)
             SimplePrimeMath.instance = new SimplePrimeMath();
@@ -52,18 +85,51 @@ export class SimplePrimeMath implements PrimeMath {
     }
 }
 
+/**
+ * Implements `PrimeMath` such that all queries are cached so that subsequent queries are faster.
+ */
 export class CachedPrimeMath implements PrimeMath {
+    /**
+     * The singleton instance.
+     *
+     * @private
+     */
     private static instance: CachedPrimeMath;
+    /**
+     * The underlying `SimplePrimeMath` instance of which the answers are cached.
+     *
+     * @private
+     */
     private static simple: SimplePrimeMath = SimplePrimeMath.getInstance();
 
+    /**
+     * Cached outputs for `isPrime` invocations.
+     *
+     * @private
+     */
     private isPrimeCache: Map<number, boolean> = new Map();
+    /**
+     * Cached outputs for `decomposeCache` invocations.
+     *
+     * @private
+     */
     private decomposeCache: Map<number, number[]> = new Map();
 
 
+    /**
+     * Constructs a new instance.
+     *
+     * @private
+     */
     private constructor() {
         // Do nothing
     }
 
+    /**
+     * Returns the singleton instance.
+     *
+     * @return the singleton instance
+     */
     public static getInstance(): CachedPrimeMath {
         if (!CachedPrimeMath.instance)
             CachedPrimeMath.instance = new CachedPrimeMath();
@@ -81,6 +147,17 @@ export class CachedPrimeMath implements PrimeMath {
     }
 
 
+    /**
+     * Invokes `fun` given `input`, and stores its output in `cache`.
+     *
+     * If `fun(input)` has previously been invoked, then the previous output is returned immediately.
+     *
+     * @param input the input to pass to `fun`
+     * @param fun the function to invoke with `input`
+     * @param cache the cache to store the output of `fun` in, and to read previous outputs from
+     * @return the output of `fun(input)`, or the previously stored output if there is one
+     * @private
+     */
     private static invokeCached<IN, OUT>(input: IN, fun: (_: IN) => OUT, cache: Map<IN, OUT>): OUT {
         if (cache.has(input))
             return cache.get(input)!!;