1 import { ComputedLine, Line } from './Line';
2 import TaxReturn from './TaxReturn';
3 import Form, { isFormT } from './Form';
4 import { InconsistencyError, NotFoundError } from './Errors';
6 test('add and get line', () => {
7 const l = new ComputedLine<number>(() => 42);
9 class TestForm extends Form<TestForm['_lines']> {
10 readonly name = 'Test Form';
12 protected readonly _lines = { '1': l };
15 const f = new TestForm();
16 expect(f.getLine('1')).toBe(l);
19 test('get non-existent line', () => {
20 class TestForm extends Form<TestForm['_lines']> {
21 readonly name = 'Test';
22 protected readonly _lines = {};
25 const f = new TestForm();
26 const fAsAny: Form<any> = f;
27 expect(() => fAsAny.getLine('line')).toThrow(NotFoundError);
30 //expect(() => f.getLine('line')).toThrow(NotFoundError);
38 class TestForm extends Form<any, TestInput> {
39 readonly name = '1040';
41 protected readonly _lines = null;
44 const f = new TestForm({ filingStatus: 'S', money: 100.0 });
45 expect(f.getInput('filingStatus')).toBe('S');
48 test('get value', () => {
49 class TestForm extends Form<TestForm['_lines']> {
50 readonly name = 'Form';
52 protected readonly _lines = {
53 line: new ComputedLine<number>(() => 42),
57 const f = new TestForm();
58 const tr = new TaxReturn(2019);
59 expect(f.getValue(tr, 'line')).toBe(42);
62 //let s: string = f.getValue(tr, 'line');
64 const fAsAny: Form<any> = f;
65 expect(() => fAsAny.getValue(tr, 'other')).toThrow(NotFoundError);
67 //expect(() => f.getValue(tr, 'other')).toThrow(NotFoundError);
70 test('form types', () => {
71 class FormA extends Form<any> {
73 protected readonly _lines = {};
75 class FormB extends Form<any> {
77 protected readonly _lines = {};
80 expect(isFormT(new FormA(), FormA)).toBe(true);
81 expect(isFormT(new FormB(), FormA)).toBe(false);
82 expect(isFormT(new FormA(), FormB)).toBe(false);
83 expect(isFormT(new FormB(), FormB)).toBe(true);
87 abstract class Form2<L extends { [key: string]: Line<any> } , I> {
88 abstract readonly name: string;
90 protected abstract readonly _lines: L;
91 protected abstract readonly _input?: I;
93 getLine<K extends keyof L>(key: K): L[K] {
94 return this._lines[key];
97 getInput<K extends keyof I>(key: K): I[K] {
98 return this._input[key];
101 getValue<T, K extends keyof L>(tr: TaxReturn, key: K): T {
102 const line = this.getLine(key);
103 return line.value(tr);
107 class FormG extends Form2<FormG['_lines'], FormG['_input']> {
110 protected readonly _lines = {
111 x: new ComputedLine('moo', () => 42),
112 z: new ComputedLine('moo', () => 36),
114 protected readonly _input = null;
118 getLineImpl<T, K extends keyof T>(lines: T, k: K): T[K] {
122 allLines(): FormG['_lines'] {
126 LINE = k => this.getLineImpl(this._lines, k);
128 testLine<K extends keyof ReturnType<FormG['allLines']>>(k: K): any {
129 return this.getLineImpl(this._lines, k);
133 test('testing', () => {
134 const g = new FormG();
135 let v = g.testLine('x'); //g.getLineImpl(g._lines, 'x');
136 let v2 = g.getValue(null, 'z');
137 throw new Error(`v = ${v2}`);