Merge pull request #10 from airtoxin/interface

Add Interface type

src/Codec/Interface.test.ts

@@ -0,0 +1,20 @@
+import { Interface } from "./Interface";
+import { GetType, optional, Right, string } from "purify-ts";
+
+describe("Interface", () => {
+  const c = Interface({ str: string, ops: optional(string) });
+
+  it("should return interface Codec", () => {
+    expect(c.decode({ str: "foo" })).toEqual(Right({ str: "foo" }));
+    // compile test
+    const v: GetType<typeof c> = { str: "foo" };
+    expect(v).toEqual({ str: "foo" });
+  });
+
+  it("should return the type accepting object that its optional field to be not defined", () => {
+    // compile test: 'ops' field not defined but acceptable
+    // `GetType<typeof c>` equals to `{ str: string, ops?: string | undefined }`
+    const v: GetType<typeof c> = { str: "foo" };
+    expect(v).toEqual({ str: "foo" });
+  });
+});

src/Codec/Interface.ts

@@ -0,0 +1,24 @@
+import { Codec, GetType } from "purify-ts";
+
+export const Interface = <T extends Record<string, Codec<any>>>(
+  properties: T
+): Codec<
+  {
+    [K in keyof ({
+      [K in keyof Pick<
+        T,
+        {
+          [K in keyof T]-?: undefined extends GetType<T[K]> ? never : K;
+        }[keyof T]
+      >]: GetType<T[K]>;
+    } &
+      {
+        [K in keyof Pick<
+          T,
+          {
+            [K in keyof T]-?: undefined extends GetType<T[K]> ? K : never;
+          }[keyof T]
+        >]?: Exclude<GetType<T[K]>, undefined>;
+      })]: GetType<T[K]>;
+  }
+> => Codec.interface(properties) as any;

src/Either/index.ts

@@ -0,0 +1 @@
+export * from "./sequenceWeak";

src/index.ts

@@ -0,0 +1,2 @@
+export * from "./Codec";
+export * from "./Either";