iamguid / ngx-mf Goto Github PK

  it('NullTest', () => {
    interface NullTest {
      readonly nonNullable: string;
      readonly nullable: string | null;
    }

    type TestForm = FormModel<NullTest, null, InferModeFromModel & InferModeNonNullable>;

    // creation
    const testFg: TestForm = new FormGroup<TestForm['controls']>({
      nonNullable: new FormControl<string>('nonNullable'),
      nullable: new FormControl<string | null>('')
    });

    // different form interactions that should work given the interface and form type
    testFg.controls.nullable.reset(null);
    const nullTest: NullTest = testFg.getRawValue();
    testFg.reset({
      nullable: null,
      nonNullable: 'nonNullable'
    })
  });

interface Foo {
  a: {
    b: { type: 'a', keyA: string } | { type: 'b', keyB: string }
  }
}

type Form = FormModel<Foo, { a: { b: 'group' } }, InferModeRequired & InferModeNonNullable>['controls']

builder.nonNullable.group<Form>({
    a: builder.nonNullable.group({
      b: builder.nonNullable.group({
        type: builder.nonNullable.control('a' as const),
        keyA: builder.nonNullable.control('')
      })
    })
  })

interface M {
  id: string;
}

type MF = FormModel<M>;

function getMf(): MF {
  return new FormGroup({
    id: new FormControl<string|undefined>('a', {nonNullable: true})
  });
}

export interface Model {
  foo: {
    bar: string,
    baz: string[],
  }[],
}

interface ... {
  foo: FormArray<{ bar: FormControl<string>, baz: FormArray<string> }>
}

interface Model {
    a: string;
}

type ModelFormNonRequired = FormModel<Model, null, InferModeFromModel>;
type ModelFormRequired = FormModel<Model, null, InferModeRequired & InferModeFromModel>;

const groupNonRequired = this.fb.group<ModelFormNonRequired['controls']>({ a: new FormControl('', { nonNullable: true }) });
const groupRequired = this.fb.group<ModelFormRequired['controls']>({ a: new FormControl('', { nonNullable: true }) });

const aNonRequired = groupRequired.value.a; // typeof a: string | undefined
const aRequired = groupRequired.value.a; // typeof a: string | undefined

interface Model {
    a: string;
    b: string;
}

// Works
type ModelForm1 = FormModel<Model>;

// Works
type ModelForm2 = FormModel<Model, { b: Replace<FormControl<number | null>> }>;

// "Works" by having an error that { c ... } does not satisfy the constraint.
type ModelForm3 = FormModel<Model, { c: Replace<FormControl<number | null>> }>; 

// Works, no error
type ModelForm4 = FormModel<Model, { b: Replace<FormControl<number | null>>; c: Replace<FormControl<string | number>> }>;