Add option to turn off returning the value in the type response

Author: ericallam

src/@types.ts

@@ -2,39 +2,39 @@ import { JSONStringFormat, JSONObjectFormat } from "./formats";
 
 export type JSONNullType = {
   name: "null";
-  value: null;
+  value?: null;
 };
 
 export type JSONBoolType = {
   name: "bool";
-  value: boolean;
+  value?: boolean;
 };
 
 export type JSONFloatType = {
   name: "float";
-  value: number;
+  value?: number;
 };
 
 export type JSONIntType = {
   name: "int";
-  value: number;
+  value?: number;
 };
 
 export type JSONStringType = {
   name: "string";
   format?: JSONStringFormat;
-  value: string;
+  value?: string;
 };
 
 export type JSONObjectType = {
   name: "object";
-  value: object;
   format?: JSONObjectFormat;
+  value?: object;
 };
 
 export type JSONArrayType = {
   name: "array";
-  value: Array<unknown>;
+  value?: Array<unknown>;
 };
 
 export type JSONValueType =

src/index.ts

@@ -4,41 +4,53 @@ import { inferFormat, inferObjectFormat } from "./formats";
 export { JSONValueType };
 export { JSONStringFormat } from "./formats";
 
-export function inferType(value: unknown): JSONValueType {
+export type InferOptions = {
+  returnValue?: "yes" | "no";
+};
+
+export function inferType(value: unknown, options?: InferOptions): JSONValueType {
+  const opts: Required<InferOptions> = Object.assign({}, { returnValue: "yes" }, options);
+
+  const shouldReturnValue = opts.returnValue === "yes";
+
   if (value === null) {
-    return { name: "null", value: null };
+    return { name: "null", value: shouldReturnValue ? null : undefined };
   }
 
   if (typeof value === "boolean") {
-    return { name: "bool", value };
+    return { name: "bool", value: shouldReturnValue ? value : undefined };
   }
 
   if (typeof value === "number") {
     if (Number.isInteger(value)) {
-      return { name: "int", value };
+      return { name: "int", value: shouldReturnValue ? value : undefined };
     } else {
-      return { name: "float", value };
+      return { name: "float", value: shouldReturnValue ? value : undefined };
     }
   }
 
   if (typeof value === "string") {
-    return { name: "string", value, format: inferFormat(value) };
+    return {
+      name: "string",
+      value: shouldReturnValue ? value : undefined,
+      format: inferFormat(value),
+    };
   }
 
   if (typeof value === "object") {
     if (Array.isArray(value)) {
       return {
         name: "array",
-        value: value,
+        value: shouldReturnValue ? value : undefined,
       };
     }
 
     return {
       name: "object",
-      value,
       format: inferObjectFormat(value),
+      value: shouldReturnValue ? value : undefined,
     };
   }
 
-  return { name: "null", value: null };
+  return { name: "null", value: shouldReturnValue ? null : undefined };
 }

tests/basicTypes.test.ts

@@ -15,6 +15,10 @@ test("It should infer basic types", () => {
   expect(inferType([{ foo: "bar" }])).toEqual({ name: "array", value: [{ foo: "bar" }] });
 });
 
+test("it should allow an option to not include the values in the result", () => {
+  expect(inferType("", { returnValue: "no" })).toEqual({ name: "string" });
+});
+
 test("It should narrow the type of the value", () => {
   const unknownInfer = (value: unknown): number | undefined => {
     const result = inferType(value);