feat(stringify): add serialization function for accept-ranges header field

Author: TomokiMiyauci

README.md

@@ -29,7 +29,8 @@ assertEquals(parseAcceptRanges(`bytes, unknown`), ["bytes", "unknown"]);
 ### Throwing error
 
 Throws `SyntaxError` if the input is invalid
-[`<Accept-Ranges>`](https://www.rfc-editor.org/rfc/rfc9110#section-14.3-2).
+[`<Accept-Ranges>`](https://www.rfc-editor.org/rfc/rfc9110#section-14.3-2)
+syntax.
 
 ```ts
 import { parseAcceptRanges } from "https://deno.land/x/accept_ranges_parser@$VERSION/parse.ts";
@@ -38,6 +39,29 @@ import { assertThrows } from "https://deno.land/std/testing/asserts.ts";
 assertThrows(() => parseAcceptRanges("<invalid>"));
 ```
 
+## Serialization
+
+Serialize string of array into string.
+
+```ts
+import { stringifyAcceptRanges } from "https://deno.land/x/accept_ranges_parser@$VERSION/stringify.ts";
+import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+
+assertEquals(stringifyAcceptRanges(["bytes"]), "bytes");
+```
+
+### Throwing error
+
+Throws `TypeError` if the element contains invalid
+[`<range-unit>`](https://www.rfc-editor.org/rfc/rfc9110#section-14.1-3) syntax.
+
+```ts
+import { stringifyAcceptRanges } from "https://deno.land/x/accept_ranges_parser@$VERSION/stringify.ts";
+import { assertThrows } from "https://deno.land/std/testing/asserts.ts";
+
+assertThrows(() => stringifyAcceptRanges(["<invalid>", "none"]));
+```
+
 ## AcceptRanges
 
 `AcceptRanges` is a subtype of array with the following characteristics.

_tools/meta.ts

@@ -36,4 +36,11 @@ export const makeOptions = (version: string): BuildOptions => ({
     publishConfig: { access: "public" },
   },
   packageManager: "pnpm",
+  mappings: {
+    "https://deno.land/x/[email protected]/is_string.ts": {
+      name: "@miyauci/isx",
+      version: "1.1.0",
+      subPath: "is_string",
+    },
+  },
 });

constants.ts

@@ -3,4 +3,5 @@
 
 export const enum Msg {
   InvalidSyntax = "invalid <Accept-Ranges> syntax.",
+  InvalidRangeUnit = "invalid <range-unit> syntax.",
 }

deno.lock

@@ -1,6 +1,8 @@
 // Copyright 2023-latest the httpland authors. All rights reserved. MIT license.
 // This module is browser compatible.
 
+export { isString } from "https://deno.land/x/[email protected]/is_string.ts";
+
 // TODO:(miyauci) Packaging and externalization this module.
 
 export type UppercaseLetter =

deps.ts

@@ -2,5 +2,6 @@
 // This module is browser compatible.
 
 export { parseAcceptRanges } from "./parse.ts";
+export { stringifyAcceptRanges } from "./stringify.ts";
 export type { AcceptRanges } from "./types.ts";
 export { type Token } from "./deps.ts";

mod.ts

@@ -0,0 +1,29 @@
+import { isString } from "./deps.ts";
+import { isTokenFormat } from "./utils.ts";
+import { Msg } from "./constants.ts";
+
+/** Serialize string of array into string.
+ *
+ * @example
+ * ```ts
+ * import { stringifyAcceptRanges } from "https://deno.land/x/accept_ranges_parser@$VERSION/stringify.ts";
+ * import { assertEquals } from "https://deno.land/std/testing/asserts.ts";
+ *
+ * assertEquals(stringifyAcceptRanges(["bytes"]), "bytes");
+ * ```
+ *
+ * @throws {TypeError} If the input is invalid [`<range-unit>`](https://www.rfc-editor.org/rfc/rfc9110#section-14.1-3) format.
+ */
+export function stringifyAcceptRanges(
+  acceptRanges: string | readonly [string, ...string[]],
+): string {
+  const targets = isString(acceptRanges) ? [acceptRanges] : acceptRanges;
+
+  targets.forEach((rangeUnit) => {
+    if (!isTokenFormat(rangeUnit)) {
+      throw TypeError(`${Msg.InvalidRangeUnit} "${rangeUnit}"`);
+    }
+  });
+
+  return targets.join(", ");
+}

stringify.ts

@@ -0,0 +1,72 @@
+import { stringifyAcceptRanges } from "./stringify.ts";
+import {
+  assertEquals,
+  assertIsError,
+  assertThrows,
+  describe,
+  it,
+} from "./_dev_deps.ts";
+
+describe("stringifyAcceptRanges", () => {
+  it("should return string if the input is valid string", () => {
+    const table: string[] = ["bytes", "none"];
+
+    table.forEach((input) => {
+      assertEquals(stringifyAcceptRanges(input), input);
+    });
+  });
+
+  it("should return string if the input is valid string of array", () => {
+    const table: [[string, ...string[]], string][] = [
+      [["bytes"], "bytes"],
+      [["bytes", "unknown"], "bytes, unknown"],
+    ];
+
+    table.forEach(([input, expected]) => {
+      assertEquals(stringifyAcceptRanges(input), expected);
+    });
+  });
+
+  it("should throw error if the input is invalid string", () => {
+    const table: string[] = [
+      "",
+      " ",
+      "bytes, none",
+      "a ",
+      " a",
+      ",",
+      " ,",
+      `"a"`,
+      `"a, b"`,
+    ];
+
+    table.forEach((input) => {
+      assertThrows(() => stringifyAcceptRanges(input));
+    });
+  });
+
+  it("should throw error if the array input has is invalid string", () => {
+    const table: [string, ...string[]][] = [
+      [""],
+      ["", ""],
+      ["", "", "", ""],
+      ["", "ok"],
+      ["ng", ","],
+    ];
+
+    table.forEach((input) => {
+      assertThrows(() => stringifyAcceptRanges(input));
+    });
+  });
+
+  it("should be error message", () => {
+    let err;
+    try {
+      stringifyAcceptRanges("");
+    } catch (e) {
+      err = e;
+    } finally {
+      assertIsError(err, TypeError, `invalid <range-unit> syntax. ""`);
+    }
+  });
+});