chore: add helpers

Author: JordonPhillips

packages/smithy-client/src/index.ts

@@ -7,6 +7,7 @@ export * from "./get-array-if-single-item";
 export * from "./get-value-from-text-node";
 export * from "./lazy-json";
 export * from "./parse-utils";
+export * from "./ser-utils";
 export * from "./date-utils";
 export * from "./split-every";
 export * from "./constants";

packages/smithy-client/src/parse-utils.spec.ts

@@ -1,4 +1,4 @@
-import { parseBoolean } from "./parse-utils";
+import { handleFloat, parseBoolean } from "./parse-utils";
 import { expectBoolean, expectNumber, expectString } from "./parse-utils";
 
 describe("parseBoolean", () => {
@@ -111,3 +111,26 @@ describe("expectString", () => {
     expect(() => expectString({})).toThrowError();
   });
 });
+
+describe("handleFloat", () => {
+  it("accepts non-numeric floats as strings", () => {
+    expect(handleFloat("NaN")).toEqual(NaN);
+    expect(handleFloat("Infinity")).toEqual(Infinity);
+    expect(handleFloat("-Infinity")).toEqual(-Infinity);
+  });
+
+  it("rejects numeric strings", () => {
+    expect(() => handleFloat("1")).toThrowError();
+    expect(() => handleFloat("1.1")).toThrowError();
+  });
+
+  it("accepts numbers", () => {
+    expect(expectNumber(1)).toEqual(1);
+    expect(expectNumber(1.1)).toEqual(1.1);
+    expect(expectNumber(Infinity)).toEqual(Infinity);
+    expect(expectNumber(-Infinity)).toEqual(-Infinity);
+    expect(expectNumber(NaN)).toEqual(NaN);
+    expect(expectNumber(null)).toEqual(undefined);
+    expect(expectNumber(undefined)).toEqual(undefined);
+  });
+});

packages/smithy-client/src/parse-utils.ts

@@ -65,3 +65,27 @@ export const expectString = (value: any): string | undefined => {
   }
   throw new TypeError(`Expected string, got ${typeof value}`);
 };
+
+/**
+ * Asserts a value is a number and returns it, and also converts string
+ * representations of non-numeric floats into Numbers.
+ *
+ * @param value A number or string representation of a non-numeric float.
+ * @returns The value as a number, undefined if it's null/undefined,
+ *     otherwise an error is thrown.
+ */
+export const handleFloat = (value: string | number): number | undefined => {
+  if (typeof value == "string") {
+    switch (value) {
+      case "NaN":
+        return NaN;
+      case "Infinity":
+        return Infinity;
+      case "-Infinity":
+        return -Infinity;
+      default:
+        throw new Error(`Unable to parse float value: ${value}`);
+    }
+  }
+  return expectNumber(value);
+};

packages/smithy-client/src/ser-utils.spec.ts

@@ -0,0 +1,14 @@
+import { serializeFloat } from "./ser-utils";
+
+describe("serializeFloat", () => {
+  it("handles non-numerics", () => {
+    expect(serializeFloat(NaN)).toEqual("NaN");
+    expect(serializeFloat(Infinity)).toEqual("Infinity");
+    expect(serializeFloat(-Infinity)).toEqual("-Infinity");
+  });
+
+  it("handles normal numbers", () => {
+    expect(serializeFloat(1)).toEqual(1);
+    expect(serializeFloat(1.1)).toEqual(1.1);
+  });
+});

packages/smithy-client/src/ser-utils.ts

@@ -0,0 +1,20 @@
+/**
+ * Serializes a number, turning non-numeric values into strings.
+ *
+ * @param value The number to serialize.
+ * @returns A number, or a string if the given number was non-numeric.
+ */
+export const serializeFloat = (value: number): string | number => {
+  // NaN is not equal to everything, including itself.
+  if (value !== value) {
+    return "NaN";
+  }
+  switch (value) {
+    case Infinity:
+      return "Infinity";
+    case -Infinity:
+      return "-Infinity";
+    default:
+      return value;
+  }
+};