refactor: library weight reduction, more unit tests and additions to

README

Author: vanska

.changeset/honest-cougars-beam.md

@@ -0,0 +1,5 @@
+---
+"typed-string-interpolation": patch
+---
+
+Library weight reduction

README.md

@@ -15,8 +15,8 @@
 - Options to customize return, pattern matching and sanity checking
 - Both ES Module and CommonJS distributions available. Use anywhere!
 - Tiny footprint:
-  - ES Module: `424B` Gzipped (`660B` unpacked)
-  - CommonJS: `660B` Gzipped (`1.13kB` unpacked)
+  - ES Module: `396B` Gzipped (`572B` unpacked)
+  - CommonJS: `634B` Gzipped (`1.04kB` unpacked)
 
 ## Motivation
 
@@ -61,6 +61,11 @@ stringInterpolation("You have {{n}} messages", {
 }) // ["You have ", <strong>3</strong>, " messages"]
 ```
 
+For more example use cases, see the unit test files in the repository:
+
+- [Unit tests for library logic](src/__tests__/stringInterpolation.test.ts)
+- [Unit tests for inferred Typescript types](src/__typetests__/stringInterpolation.test.ts)
+
 ## TypeScript support
 
 If the string can be joined you'll get back a `string` type. Otherwise a `union` type within an array is returned based on the passed in variables.
@@ -115,7 +120,19 @@ stringInterpolation(
 Provide your own `RegExp` pattern for variable matching. Must be defined as:
 
 ```ts
-pattern: new RegExp(/\{{([^{]+)}}/g)
+pattern: new RegExp(/\{{([^{]+)}}/g) // Default
+```
+
+Example alternative pattern:
+
+```ts
+stringInterpolation(
+  "Hi %{name}",
+  { name: "John" },
+  {
+    pattern: /%\{([^}]+)\}/g,
+  },
+),
 ```
 
 `sanity`

src/__tests__/stringInterpolation.test.ts

@@ -67,4 +67,70 @@ describe("stringInterpolation()", () => {
       "foobar",
     )
   })
+
+  test("Interpolate falsy values (0 and empty string)", () => {
+    expect(
+      stringInterpolation("Zero: {{v0}}, Empty: '{{v1}}'", { v0: 0, v1: "" }),
+    ).toBe("Zero: 0, Empty: ''")
+  })
+
+  test("Return raw with number when raw option is true", () => {
+    expect(
+      stringInterpolation("Num {{n}}!", { n: 42 }, { raw: true }),
+    ).toStrictEqual(["Num ", 42, "!"])
+  })
+
+  test("Custom pattern option works", () => {
+    expect(
+      stringInterpolation(
+        "Hi %{name}",
+        { name: "John" },
+        {
+          pattern: /%\{([^}]+)\}/g,
+        },
+      ),
+    ).toBe("Hi John")
+  })
+
+  test("Sanity disabled allows extra variables without throwing", () => {
+    expect(
+      stringInterpolation(
+        "Hello {{world}}",
+        { world: "earth", extra: "x" },
+        { sanity: false },
+      ),
+    ).toBe("Hello earth")
+  })
+
+  test("Duplicate variables with sanity enabled triggers count mismatch", () => {
+    expect(() =>
+      stringInterpolation("{{name}} {{name}}", { name: "A" }),
+    ).toThrow("Variable count mismatch")
+  })
+
+  test("No variables returns input unchanged", () => {
+    expect(stringInterpolation("Just text", {} as any)).toBe("Just text")
+  })
+
+  test("Numeric variable key is supported", () => {
+    expect(stringInterpolation("Value {{0}}", { 0: "zero" } as any)).toBe(
+      "Value zero",
+    )
+  })
+
+  test("Empty input with sanity disabled returns empty string", () => {
+    expect(stringInterpolation("", { a: 1 } as any, { sanity: false })).toBe("")
+  })
+
+  test("Raw output with multiple variables returns segments array", () => {
+    expect(
+      stringInterpolation("A{{x}}B{{y}}C", { x: "X", y: "Y" }, { raw: true }),
+    ).toStrictEqual(["A", "X", "B", "Y", "C"])
+  })
+
+  test("Missing variable with sanity disabled yields raw array with undefined", () => {
+    expect(
+      stringInterpolation("Hello {{world}}", {} as any, { sanity: false }),
+    ).toStrictEqual(["Hello ", undefined])
+  })
 })

src/__typetests__/stringInterpolation.test.tsx

@@ -3,71 +3,125 @@ import { stringInterpolation } from "../index"
 
 // ~~~~~~~~~~~~~~ TYPESCRIPT TYPE TESTING ~~~~~~~~~~~~~~
 
-expectType<string>(
-  stringInterpolation("hello {{one}}", {
-    one: "one",
+describe("stringInterpolation types", () => {
+  test("returns string for single variable string", () => {
+    expectType<string>(
+      stringInterpolation("hello {{one}}", {
+        one: "one",
+      }),
+    )
+
+    expectType<string>(
+      stringInterpolation("hello {{one}}", {
+        one: "one",
+      }),
+    )
+  })
+
+  test("returns string[] when raw is true with string values", () => {
+    expectType<string[]>(
+      stringInterpolation(
+        "hello {{one}}",
+        {
+          one: "one",
+        },
+        { raw: true },
+      ),
+    )
   })
-)
 
-expectType<string>(
-  stringInterpolation("hello {{one}}", {
-    one: "one",
+  test("returns string when mixed string and number are joinable", () => {
+    expectType<string>(
+      stringInterpolation("hello {{one}} {{two}}", {
+        one: "one",
+        two: 2,
+      }),
+    )
   })
-)
 
-expectType<string[]>(
-  stringInterpolation(
-    "hello {{one}}",
-    {
-      one: "one",
-    },
-    { raw: true }
-  )
-)
+  test("returns string when variable is a number", () => {
+    expectType<string>(
+      stringInterpolation("hello {{one}}", {
+        one: 2,
+      }),
+    )
+  })
+
+  test("returns array union when non-primitive element is included", () => {
+    expectType<
+      (
+        | string
+        | number
+        | {
+            type: string
+            props: {
+              className: string
+              children: string
+            }
+          }
+      )[]
+    >(
+      stringInterpolation("hello {{one}} {{two}} {{three}}", {
+        one: "one",
+        two: 2,
+        three: {
+          type: "span",
+          props: {
+            className: "bold",
+            children: "one",
+          },
+        },
+      }),
+    )
+  })
+
+  test("returns array including Date when Date is included", () => {
+    expectType<(string | number | Date)[]>(
+      stringInterpolation("hello {{one}} {{two}} {{three}}", {
+        one: "one",
+        two: 2,
+        three: new Date(),
+      }),
+    )
+  })
+
+  test("raw true with only string/number returns (string | number)[]", () => {
+    expectType<(string | number)[]>(
+      stringInterpolation("num {{n}}", { n: 123 }, { raw: true }),
+    )
+
+    expectType<(string | number)[]>(
+      stringInterpolation("a {{a}} b {{b}}", { a: "A", b: 2 }, { raw: true }),
+    )
+  })
 
-expectType<string>(
-  stringInterpolation("hello {{one}} {{two}}", {
-    one: "one",
-    two: 2,
+  test("raw false with non-(string|number) still returns array", () => {
+    expectType<(string | Date)[]>(
+      stringInterpolation("date {{d}}", { d: new Date() }, { raw: false }),
+    )
   })
-)
 
-expectType<string>(
-  stringInterpolation("hello {{one}}", {
-    one: 2,
+  test("including a function forces array regardless of raw option", () => {
+    const fnReturnsString: () => string = () => "ok"
+    expectType<(string | (() => string))[]>(
+      stringInterpolation("fn {{f}}", { f: fnReturnsString }),
+    )
   })
-)
 
-expectType<
-  (
-    | string
-    | number
-    | {
-        type: string
-        props: {
-          className: string
-          children: string
-        }
-      }
-  )[]
->(
-  stringInterpolation("hello {{one}} {{two}} {{three}}", {
-    one: "one",
-    two: 2,
-    three: {
-      type: "span",
-      props: {
-        className: "bold",
-        children: "one",
-      },
-    },
+  test("raw true + string values returns string[]", () => {
+    expectType<string[]>(
+      stringInterpolation("hello {{one}}", { one: "one" }, { raw: true }),
+    )
   })
-)
 
-expectType<(string | number | Date)[]>(
-  stringInterpolation("hello {{one}} {{two}} {{three}}", {
-    one: "one",
-    two: 2,
-    three: new Date(),
+  test("raw true with object value returns array including object type", () => {
+    expectType<
+      (
+        | string
+        | {
+            id: number
+          }
+      )[]
+    >(stringInterpolation("obj {{o}}", { o: { id: 1 } }, { raw: true }))
   })
-)
+})