Added getCellBoundingBox to find the bounding box of an array of [x, y][] cell positions

Added numberPairArrayToMatrix util function to convert an array of [x, y][] cell positions to a matrix of 0's and 1's
Added Set2D data structure from cobyj33/automata
Moved ByteArray to core/byteArray.ts

Added support for Life 1.06 file format
Started adding tests for Life 1.06 file format
Added support for plaintext file format

Added functionality to writeLife106String to automatically ignore duplicate values
Added writePlainTextMetadata to write description data for the plaintext format
Added writePlainTextFromCoordinates and writePlainTextMatrix to be able to build the plaintext format from both forms of data

Author: cobyj33

core/byteArray.ts

@@ -0,0 +1,31 @@
+
+
+export class ByteArray {
+    private data: number[]
+
+    constructor() {
+      this.data = []
+    }
+  
+    getData() : Uint8ClampedArray {
+      return Uint8ClampedArray.from(this.data)
+    }
+
+    getString(): string {
+        return this.data.map(val => String.fromCharCode(val)).join("")
+    }
+  
+    writeByte(val: number): void {
+      this.data.push(val)
+    }
+  
+    writeUTFBytes(str: string): void {
+      for (var len = str.length, i = 0; i < len; i++) {
+        this.writeByte(str.charCodeAt(i))
+      }
+    }
+  
+    writeBytes(array: number[]): void {
+        array.forEach(num => this.writeByte(num))
+    }
+}

core/set2D.ts

@@ -0,0 +1,121 @@
+export class Set2D {
+    private map: Map<number, Set<number>> = new Map<number, Set<number>>();
+    private _length: number;
+
+    constructor(values: Array<[number, number]> | Set2D = []) {
+        this._length = 0;
+
+        if (Array.isArray(values)) {
+            values.forEach(value => this.add(value[0], value[1])); 
+        } else {
+            values.forEach(([first, second]) => this.add(first, second))
+        }
+    }
+
+    fullClear() {
+        this.map = new Map();
+        this._length = 0;
+    }
+
+    clear() {
+        [...this.map.values()].forEach(set => set.clear())
+        this._length = 0;
+    }
+
+    get length(): number { return this._length } 
+
+    static fromNumberMatrix(values: number[][]): Set2D {
+        const set = new Set2D();
+        for (let row = 0; row < values.length; row++) {
+            for (let col = 0; col < values[row].length; col++) {
+                if (values[row][col] === 1) {
+                    set.add(row, col)
+                }
+            }
+        }
+        return set;
+    }
+
+    getTuples(): Array<[number, number]> {
+        const arr = new Array<[number, number]>(this.length)
+        let i = 0;
+        this.forEach((pair) => {
+            arr[i] = pair
+            i++;
+        })
+
+        return arr
+    }
+
+    forEach(callbackfn: (curr: [number, number]) => void) {
+        this.map.forEach((set, first) => set.forEach(second => callbackfn([first, second])   ))
+    }
+    
+
+    add(first: number, second: number): void {
+        if (this.map.get(first)?.has(second) === false) {
+            this.map.get(first)?.add(second); 
+            this._length += 1;
+        } else if (this.map.has(first) === false) {
+            this.map.set(first, new Set<number>([second]))
+            this._length += 1;
+        }
+
+    }
+
+    remove(first: number, second: number): void {
+        let set: Set<number> | undefined
+        if (set = this.map.get(first)) {
+            if (set.has(second)) {
+                set.delete(second)
+                this._length -= 1;
+                // if (set.size === 0) { 
+                //     this.map.delete(first)
+                // }
+            }
+        }
+    }
+
+    has(first: number, second: number): boolean {
+        return this.map.get(first)?.has(second) || false;
+    }
+
+    hasAll(tuples: Array<[number, number]>): boolean {
+        return tuples.every(tuple => this.has(tuple[0], tuple[1]));
+    }
+
+    hasAllExact(tuples: Array<[number, number]>): boolean {
+        return tuples.length === this.length && this.hasAll(tuples);
+    }
+
+    combine(...others: Set2D[]): Set2D {
+        const set = new Set2D();
+        set.push(this, ...others);
+        return set;
+    }
+
+    push(...others: Set2D[]): void {
+        others.forEach(other => other.forEach(tuple => this.add(tuple[0], tuple[1])) );
+    }
+
+    *[Symbol.iterator](): IterableIterator<[number, number]> {
+        for (const pair of this.map) {
+            for (const second of pair[1]) {
+                yield [pair[0], second]
+            }
+        }
+    }
+
+    equals(other: Set2D): boolean {
+        if (this.length !== other.length) {
+            return false;
+        }
+        
+        for ( const entry of this ) {
+            if (other.has(entry[0], entry[1]) === false) {
+                return false;
+            }
+        }
+        return true;
+    }
+}

core/util.ts

@@ -17,3 +17,69 @@ export function isRectangularMatrix<T>(matrix: T[][]): boolean {
     }
     return true;
 }
+
+const ASCII_CHAR_CODE_0 = 48;
+const ASCII_CHAR_CODE_9 = 57;
+
+export function isDigit(digit: string): boolean {
+    return digit.length === 1 && digit.charCodeAt(0) >= 48 && digit.charCodeAt(0) <= 57
+} 
+
+export function isIntegerString(num: string): boolean {
+    for (let i = 0; i < num.length; i++) {
+        if (i === 0) {
+            if (!isDigit(num[i]) || num[i] === "-") {
+                return false;
+            }
+        } else {
+            if (!isDigit(num[i])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+export function isNumberPairArray(num: number[][]): num is [number, number][] {
+    return num.every(row => row.length === 2)
+}
+
+type Bounds = { x: number, y: number, width: number, height: number  }
+
+/**
+ * 
+ * @param positions 
+ * @returns Bounds object (maxY is given with the basis that positive is up)
+ */
+export function getCellBoundingBox(positions: [number, number][]): Bounds {
+    if (positions.length === 0) {
+        throw new Error("Cannot create bounding box over empty area");
+    }
+
+    let minY = positions[0][1];
+    let maxY = positions[0][1];
+    let minX = positions[0][0];
+    let maxX = positions[0][0];
+
+    for (let i = 0; i < positions.length; i++) {
+        minY = Math.min(minY, positions[i][1])
+        minX = Math.min(minX, positions[i][0])
+        maxY = Math.max(maxY, positions[i][1])
+        maxX = Math.max(maxX, positions[i][0])
+    }
+
+    return { x: minX, y: maxY, width: Math.abs(maxX - minX) + 1, height: Math.abs(maxY - minY) + 1 }
+}
+
+export function numberPairArrayToMatrix(positions: [number, number][]): (0 | 1)[][] {
+    if (positions.length === 0) {
+        return [];
+    }
+
+    const bounds = getCellBoundingBox(positions);
+    const matrix: (0 | 1)[][] = Array.from({ length: bounds.height }, () => new Array<0>(bounds.width).fill(0));
+    positions.forEach(position => {
+        matrix[bounds.y - position[1]][position[0] - bounds.x] = 1;
+    })
+    return matrix;
+}

formats/life105.ts

@@ -1,5 +1,7 @@
 // Life 1.05 File Format Spec: https://conwaylife.com/wiki/Life_1.05
 
+import { ByteArray } from "../core/byteArray";
+
 const LIFE_105_HEADER = "#Life 1.05" as const
 const MAX_DESCRIPTION_LINE_COUNT = 22 as const
 const LIFE_105_MAX_LINE_LENGTH = 80 as const
@@ -14,7 +16,9 @@ interface Life105Config {
 }
 
 export function writeLife105File(pattern: (0 | 1)[][], config: Life105Config): string {
-  return ""
+    const fileData = new ByteArray()
+    fileData.writeUTFBytes(LIFE_105_HEADER + "\n");
+    return fileData.getString();
 }
 
 export function readLife105File(): (0 | 1)[][] {

formats/life106.ts

@@ -0,0 +1,57 @@
+import { ByteArray } from "../core/byteArray"
+import { isIntegerString } from "../core/util"
+import { Set2D } from "../core/set2D"
+
+const LIFE_106_HEADER = "#Life 1.06" as const
+const LIFE_106_FILE_EXTENSIONS = [".lif", ".life"] as const
+
+export function writeLife106String(data: [number, number][]): string {
+    const byteArray = new ByteArray()
+    byteArray.writeUTFBytes(LIFE_106_HEADER + "\n")
+    const dupSet: Set2D = new Set2D();
+
+    for (let i = 0; i < data.length; i++) {
+        const [x, y] = data[i];
+        if (dupSet.has(x, y)) {
+            continue;
+        }
+
+        byteArray.writeUTFBytes(`${x} ${y}\n`)
+        dupSet.add(x, y)
+    }
+
+    return byteArray.getString();
+}
+
+export function readLife106String(str: string): [number, number][] {
+    if (str.startsWith(LIFE_106_HEADER + "\n")) {
+        const output: [number, number][] = []
+        const lines = str.split("\n")
+        let ended: boolean = false;
+
+        for (let i = 1; i < lines.length; i++) {
+            const nums = lines[i].trim().split(" ")
+            if (nums.length !== 2) {
+                if (nums.length === 0 || nums.every(val => val.length === 0)) {
+                    ended = true;
+                    continue;
+                }
+                throw new Error(`Invalid Life 1.06 string. Error at Line ${i}. There must be an X and a Y position only on subsequent lines after the Life 1.06 Header \n${str}\n `)
+            }
+
+            if (ended) {
+                throw new Error(`Invalid Life 1.06 string: \n${str}\n Error at Line ${i}. X and Y Values must be on subsequent lines`)
+            }
+
+            if (isIntegerString(nums[0]) && isIntegerString(nums[1])) {
+                output.push([Number.parseInt(nums[0]), Number.parseInt(nums[1])])
+            } else {
+                throw new Error(`Invalid Life 1.06 string. Error at Line ${i}. Cell positions must be integers ( got ${nums[0]} and ${nums[1]}) \n${str}\n `)
+            }
+        }
+
+        return output;
+    } else {
+        throw new Error(`Could not read Life 1.06 string. Error at Line 1: does not begin with appropriate header. Must be "${LIFE_106_HEADER}" ${str}`)
+    }
+}

formats/plaintext.ts

@@ -0,0 +1,44 @@
+import { ByteArray } from "../core/byteArray"
+import { numberPairArrayToMatrix } from "../core/util"
+
+const PLAIN_TEXT_HEADER_BEGINNING = "!Name: "
+
+function writePlainTextMetadata(byteArray: ByteArray, name: string, description: string | string[]): void {
+    byteArray.writeUTFBytes(PLAIN_TEXT_HEADER_BEGINNING + name + "\n")
+    if (description.length > 0) {
+        if (typeof(description) === "string") {
+                const lines = description.split("\n")
+                lines.forEach(line => byteArray.writeUTFBytes(`!${line}\n`))
+        } else {
+            const lines = description.flatMap(lines => lines.split("\n"))
+            lines.forEach(line => byteArray.writeUTFBytes(`!${line}\n`))
+        }
+    }
+
+    byteArray.writeUTFBytes("!\n")
+}
+
+export function writePlainTextFromCoordinates(positions: [number, number][], name: string, description: string | string[]): string {
+    return writePlainTextMatrix(numberPairArrayToMatrix(positions) as (0 | 1)[][], name, description)    
+}
+
+export function writePlainTextMatrix(data: (0 | 1)[][], name: string, description: string | string[]): string {
+    const byteArray = new ByteArray();
+    writePlainTextMetadata(byteArray, name, description)
+
+    const height = data.length;
+    const width = Math.max(...data.map(row => row.length))
+
+    for (let row = 0; row < height; row++) {
+        for (let col = 0; col < width; col++) {
+            if (col >= data[row].length) {
+                byteArray.writeUTFBytes(".");
+            } else {
+                byteArray.writeUTFBytes(data[row][col] === 0 ? "." : "O");
+            }
+        }
+        byteArray.writeUTFBytes("\n")
+    }
+
+    return byteArray.getString();
+}

formats/rule.ts

@@ -1,5 +1,6 @@
 
 
+type LifeRuleData = { birth: number[], survival: number[] }
 
 export function isValidLifeString(lifeString: string, errorOutput?: (error: string) => any) {
     const error = getLifeStringError(lifeString);

index.ts

@@ -1,3 +1,9 @@
-import { hello } from "./formats/life105"
+import { readLife106String, writeLife106String } from "./formats/life106"
+import { writePlainTextFromCoordinates, writePlainTextMatrix } from "./formats/plaintext"
 
-console.log("run", hello())
+const life106String = writeLife106String([[0, 1], [1, 2], [2, 3], [3, 4]])
+console.log(life106String)
+console.log(readLife106String(life106String))
+
+const plainTextString = writePlainTextFromCoordinates([[0, 1], [1, 2], [2, 3], [3, 4]], "Steps", "")
+console.log(plainTextString)

package.json

@@ -7,7 +7,8 @@
     "@types/jest": "^29.4.0",
     "babel-jest": "^29.4.3",
     "jest": "^29.4.3",
-    "ts-node": "^10.9.1"
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
   },
   "scripts": {
     "test": "jest"

tests/data/life106/acorn.lif

@@ -0,0 +1,4 @@
+#Life 1.06
+0 0
+1 0
+2 0