@chr33s/pdf-dfa 5.0.0

package/test/state-machine.test.ts

@@ -0,0 +1,132 @@
+import { describe, expect, test } from "vitest";
+import StateMachine, { FAIL_STATE, INITIAL_STATE } from "../src/state-machine.js";
+
+describe("StateMachine", () => {
+  describe("constants", () => {
+    test("INITIAL_STATE is 1", () => {
+      expect(INITIAL_STATE).toBe(1);
+    });
+
+    test("FAIL_STATE is 0", () => {
+      expect(FAIL_STATE).toBe(0);
+    });
+  });
+
+  describe("match", () => {
+    test("should return empty matches for empty input", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [0]],
+        accepting: [false, true],
+        tags: [[], []],
+      });
+      const matches = Array.from(sm.match([]));
+      expect(matches).toEqual([]);
+    });
+
+    test("should handle no accepting states", () => {
+      const sm = new StateMachine({
+        stateTable: [[1], [1]],
+        accepting: [false, false],
+        tags: [[], []],
+      });
+      const matches = Array.from(sm.match([0, 0, 0]));
+      expect(matches).toEqual([]);
+    });
+
+    test("should handle single accepting state at start", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], []],
+      });
+      const matches = Array.from(sm.match([0]));
+      expect(matches).toEqual([[0, 0, []]]);
+    });
+
+    test("should handle multiple consecutive matches", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], []],
+      });
+      const matches = Array.from(sm.match([0, 0, 0]));
+      expect(matches).toEqual([
+        [0, 0, []],
+        [1, 1, []],
+        [2, 2, []],
+      ]);
+    });
+
+    test("should return tags for accepting states", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], ["myTag"]],
+      });
+      const matches = Array.from(sm.match([0]));
+      expect(matches).toEqual([[0, 0, ["myTag"]]]);
+    });
+
+    test("should handle undefined state transitions gracefully", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], []],
+        accepting: [false, false, true],
+        tags: [[], [], []],
+      });
+      // Symbol 1 has no transition from state 1
+      const matches = Array.from(sm.match([0, 1]));
+      expect(matches).toEqual([[0, 0, []]]);
+    });
+  });
+
+  describe("apply", () => {
+    test("should call action handlers for each tag", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], ["action1"]],
+      });
+
+      const calls: Array<[string, number, number, number[]]> = [];
+      sm.apply([0, 0], {
+        action1: (start, end, slice) => calls.push(["action1", start, end, slice]),
+      });
+
+      expect(calls).toEqual([
+        ["action1", 0, 0, [0]],
+        ["action1", 1, 1, [0]],
+      ]);
+    });
+
+    test("should not call missing action handlers", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], ["missingAction"]],
+      });
+
+      const calls: string[] = [];
+      sm.apply([0], {
+        otherAction: () => calls.push("called"),
+      });
+
+      expect(calls).toEqual([]);
+    });
+
+    test("should handle multiple tags on same match", () => {
+      const sm = new StateMachine({
+        stateTable: [[], [2], [0]],
+        accepting: [false, false, true],
+        tags: [[], [], ["tag1", "tag2"]],
+      });
+
+      const calls: string[] = [];
+      sm.apply([0], {
+        tag1: () => calls.push("tag1"),
+        tag2: () => calls.push("tag2"),
+      });
+
+      expect(calls).toEqual(["tag1", "tag2"]);
+    });
+  });
+});

package/test/symbol-table.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from "vitest";
+import { Assignment, Literal, Variable } from "../src/nodes.js";
+import SymbolTable from "../src/symbol-table.js";
+
+describe("SymbolTable", () => {
+  test("should process assignments and store variables", () => {
+    const statements = [
+      new Assignment(new Variable("a"), new Literal(0)),
+      new Assignment(new Variable("main"), new Variable("a")),
+    ];
+
+    const table = new SymbolTable(statements);
+    expect(table.variables.a).toBeInstanceOf(Literal);
+    expect((table.variables.a as Literal).value).toBe(0);
+  });
+
+  test("should throw when main is not declared", () => {
+    const statements = [new Assignment(new Variable("a"), new Literal(0))];
+
+    expect(() => new SymbolTable(statements)).toThrow("No main variable declaration found");
+  });
+
+  test("should throw for undeclared identifiers", () => {
+    const statements = [new Assignment(new Variable("main"), new Variable("undeclared"))];
+
+    expect(() => new SymbolTable(statements)).toThrow("Undeclared identifier undeclared");
+  });
+
+  test("should resolve variable references", () => {
+    const statements = [
+      new Assignment(new Variable("a"), new Literal(0)),
+      new Assignment(new Variable("b"), new Variable("a")),
+      new Assignment(new Variable("main"), new Variable("b")),
+    ];
+
+    const table = new SymbolTable(statements);
+    expect(table.main).toBeInstanceOf(Literal);
+    expect((table.main as Literal).value).toBe(0);
+  });
+
+  test("should add external symbols", () => {
+    const statements = [new Assignment(new Variable("main"), new Variable("external"))];
+
+    const table = new SymbolTable(statements, { external: 42 });
+    expect(table.symbols.external).toBe(42);
+    expect(table.main).toBeInstanceOf(Literal);
+    expect((table.main as Literal).value).toBe(42);
+  });
+
+  test("should track symbol count", () => {
+    const statements = [
+      new Assignment(new Variable("a"), new Literal(0)),
+      new Assignment(new Variable("b"), new Literal(1)),
+      new Assignment(new Variable("main"), new Variable("a")),
+    ];
+
+    const table = new SymbolTable(statements);
+    // Size counts all literal assignments: a=0, b=1, and the resolved main=a (which is 0)
+    expect(table.size).toBe(3);
+  });
+
+  test("should include external symbols in size count", () => {
+    const statements = [new Assignment(new Variable("main"), new Variable("ext"))];
+
+    const table = new SymbolTable(statements, { ext: 0 });
+    // Size counts: external symbol ext=0, and the resolved main (which is also a literal)
+    expect(table.size).toBe(2);
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "vitest";
+import { addAll, equal, union } from "../src/utils.js";
+
+describe("utils", () => {
+  describe("union", () => {
+    test("should return union of two sets", () => {
+      const a = new Set([1, 2, 3]);
+      const b = new Set([3, 4, 5]);
+      const result = union(a, b);
+      expect(result).toEqual(new Set([1, 2, 3, 4, 5]));
+    });
+
+    test("should not modify original sets", () => {
+      const a = new Set([1, 2]);
+      const b = new Set([3, 4]);
+      union(a, b);
+      expect(a).toEqual(new Set([1, 2]));
+      expect(b).toEqual(new Set([3, 4]));
+    });
+
+    test("should handle empty sets", () => {
+      const a = new Set<number>();
+      const b = new Set([1, 2]);
+      expect(union(a, b)).toEqual(new Set([1, 2]));
+      expect(union(b, a)).toEqual(new Set([1, 2]));
+    });
+
+    test("should handle both empty sets", () => {
+      const a = new Set<number>();
+      const b = new Set<number>();
+      expect(union(a, b)).toEqual(new Set());
+    });
+
+    test("should work with iterable as second argument", () => {
+      const a = new Set([1, 2]);
+      const b = [3, 4];
+      const result = union(a, b);
+      expect(result).toEqual(new Set([1, 2, 3, 4]));
+    });
+  });
+
+  describe("addAll", () => {
+    test("should add all items from source to target", () => {
+      const target = new Set([1, 2]);
+      const source = new Set([3, 4]);
+      addAll(target, source);
+      expect(target).toEqual(new Set([1, 2, 3, 4]));
+    });
+
+    test("should handle duplicates", () => {
+      const target = new Set([1, 2, 3]);
+      const source = new Set([2, 3, 4]);
+      addAll(target, source);
+      expect(target).toEqual(new Set([1, 2, 3, 4]));
+    });
+
+    test("should handle empty source", () => {
+      const target = new Set([1, 2]);
+      const source = new Set<number>();
+      addAll(target, source);
+      expect(target).toEqual(new Set([1, 2]));
+    });
+
+    test("should work with array as source", () => {
+      const target = new Set([1, 2]);
+      const source = [3, 4, 5];
+      addAll(target, source);
+      expect(target).toEqual(new Set([1, 2, 3, 4, 5]));
+    });
+  });
+
+  describe("equal", () => {
+    test("should return true for identical sets", () => {
+      const a = new Set([1, 2, 3]);
+      expect(equal(a, a)).toBe(true);
+    });
+
+    test("should return true for equal sets with same elements", () => {
+      const a = new Set([1, 2, 3]);
+      const b = new Set([1, 2, 3]);
+      expect(equal(a, b)).toBe(true);
+    });
+
+    test("should return true for equal sets with different insertion order", () => {
+      const a = new Set([1, 2, 3]);
+      const b = new Set([3, 2, 1]);
+      expect(equal(a, b)).toBe(true);
+    });
+
+    test("should return false for sets with different sizes", () => {
+      const a = new Set([1, 2, 3]);
+      const b = new Set([1, 2]);
+      expect(equal(a, b)).toBe(false);
+    });
+
+    test("should return false for sets with different elements", () => {
+      const a = new Set([1, 2, 3]);
+      const b = new Set([1, 2, 4]);
+      expect(equal(a, b)).toBe(false);
+    });
+
+    test("should return true for empty sets", () => {
+      const a = new Set<number>();
+      const b = new Set<number>();
+      expect(equal(a, b)).toBe(true);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "allowJs": true,
+    "rootDir": "src",
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": [
+    "dfa.d.ts",
+    "src/**/*.ts"
+  ],
+  "exclude": [
+    "dist"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["node"],
+    "noEmit": true
+  },
+  "include": ["**/*.ts"]
+}

package/tsconfig.typecheck.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "rootDir": "."
+  },
+  "include": [
+    "**/*.ts",
+  ],
+  "exclude": [
+    "dist",
+    "node_modules",
+    "src/grammar.js",
+    "vendor"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    environment: "node",
+    include: ["test/**/*.test.ts"],
+  },
+});