716 lines
20 KiB
TypeScript
716 lines
20 KiB
TypeScript
import { Option } from "effect"
|
||
import { pipe } from "effect/Function"
|
||
import * as S from "effect/String"
|
||
import { assert, describe, it } from "vitest"
|
||
import { assertFalse, assertNone, assertSome, assertTrue, deepStrictEqual, strictEqual } from "./utils/assert.ts"
|
||
|
||
describe("String", () => {
|
||
describe("String (constructor)", () => {
|
||
it("converts values to strings", () => {
|
||
strictEqual(S.String(123), "123")
|
||
strictEqual(S.String(true), "true")
|
||
strictEqual(S.String(null), "null")
|
||
})
|
||
})
|
||
|
||
describe("isString", () => {
|
||
it("returns true for strings", () => {
|
||
assertTrue(S.isString("hello"))
|
||
assertTrue(S.isString(""))
|
||
})
|
||
|
||
it("returns false for non-strings", () => {
|
||
assertFalse(S.isString(1))
|
||
assertFalse(S.isString(null))
|
||
assertFalse(S.isString(undefined))
|
||
assertFalse(S.isString(true))
|
||
assertFalse(S.isString({}))
|
||
})
|
||
})
|
||
|
||
describe("Order", () => {
|
||
it("compares strings lexicographically", () => {
|
||
strictEqual(S.Order("apple", "banana"), -1)
|
||
strictEqual(S.Order("banana", "apple"), 1)
|
||
strictEqual(S.Order("apple", "apple"), 0)
|
||
})
|
||
|
||
it("compares empty strings", () => {
|
||
strictEqual(S.Order("", ""), 0)
|
||
strictEqual(S.Order("", "a"), -1)
|
||
strictEqual(S.Order("a", ""), 1)
|
||
})
|
||
})
|
||
|
||
describe("Equivalence", () => {
|
||
it("returns true for equal strings", () => {
|
||
assertTrue(S.Equivalence("a", "a"))
|
||
})
|
||
|
||
it("returns false for different strings", () => {
|
||
assertFalse(S.Equivalence("a", "b"))
|
||
})
|
||
})
|
||
|
||
describe("empty", () => {
|
||
it("is the empty string", () => {
|
||
strictEqual(S.empty, "")
|
||
})
|
||
})
|
||
|
||
describe("concat", () => {
|
||
it("data-first", () => {
|
||
strictEqual(S.concat("hello", " world"), "hello world")
|
||
})
|
||
|
||
it("data-last (pipeable)", () => {
|
||
strictEqual(pipe("hello", S.concat(" world")), "hello world")
|
||
})
|
||
|
||
it("concatenates empty strings", () => {
|
||
strictEqual(S.concat("", ""), "")
|
||
strictEqual(S.concat("a", ""), "a")
|
||
strictEqual(S.concat("", "b"), "b")
|
||
})
|
||
})
|
||
|
||
describe("toUpperCase", () => {
|
||
it("converts to uppercase", () => {
|
||
strictEqual(S.toUpperCase("hello"), "HELLO")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.toUpperCase(""), "")
|
||
})
|
||
|
||
it("pipeable", () => {
|
||
strictEqual(pipe("abc", S.toUpperCase), "ABC")
|
||
})
|
||
})
|
||
|
||
describe("toLowerCase", () => {
|
||
it("converts to lowercase", () => {
|
||
strictEqual(S.toLowerCase("HELLO"), "hello")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.toLowerCase(""), "")
|
||
})
|
||
})
|
||
|
||
describe("capitalize", () => {
|
||
it("capitalizes first character", () => {
|
||
strictEqual(S.capitalize("hello"), "Hello")
|
||
})
|
||
|
||
it("handles single character", () => {
|
||
strictEqual(S.capitalize("a"), "A")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.capitalize(""), "")
|
||
})
|
||
|
||
it("does not change already capitalized", () => {
|
||
strictEqual(S.capitalize("Hello"), "Hello")
|
||
})
|
||
})
|
||
|
||
describe("uncapitalize", () => {
|
||
it("uncapitalizes first character", () => {
|
||
strictEqual(S.uncapitalize("Hello"), "hello")
|
||
})
|
||
|
||
it("handles single character", () => {
|
||
strictEqual(S.uncapitalize("A"), "a")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.uncapitalize(""), "")
|
||
})
|
||
|
||
it("preserves rest of string", () => {
|
||
strictEqual(S.uncapitalize("ABC"), "aBC")
|
||
})
|
||
})
|
||
|
||
describe("replace", () => {
|
||
it("replaces first occurrence", () => {
|
||
strictEqual(pipe("abab", S.replace("b", "c")), "acab")
|
||
})
|
||
|
||
it("replaces with regex", () => {
|
||
strictEqual(pipe("abc", S.replace(/b/, "d")), "adc")
|
||
})
|
||
|
||
it("returns unchanged if no match", () => {
|
||
strictEqual(pipe("abc", S.replace("z", "x")), "abc")
|
||
})
|
||
})
|
||
|
||
describe("trim", () => {
|
||
it("trims whitespace from both ends", () => {
|
||
strictEqual(S.trim(" hello "), "hello")
|
||
})
|
||
|
||
it("trims tabs and newlines", () => {
|
||
strictEqual(S.trim("\t\nhello\t\n"), "hello")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.trim(""), "")
|
||
})
|
||
})
|
||
|
||
describe("trimStart", () => {
|
||
it("trims leading whitespace", () => {
|
||
strictEqual(S.trimStart(" hello "), "hello ")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.trimStart(""), "")
|
||
})
|
||
})
|
||
|
||
describe("trimEnd", () => {
|
||
it("trims trailing whitespace", () => {
|
||
strictEqual(S.trimEnd(" hello "), " hello")
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
strictEqual(S.trimEnd(""), "")
|
||
})
|
||
})
|
||
|
||
describe("slice", () => {
|
||
it("extracts a section", () => {
|
||
strictEqual(pipe("abcd", S.slice(1, 3)), "bc")
|
||
})
|
||
|
||
it("handles negative indices", () => {
|
||
strictEqual(pipe("hello", S.slice(-3)), "llo")
|
||
})
|
||
|
||
it("no arguments returns full string", () => {
|
||
strictEqual(pipe("hello", S.slice()), "hello")
|
||
})
|
||
})
|
||
|
||
describe("isEmpty", () => {
|
||
it("returns true for empty string", () => {
|
||
assertTrue(S.isEmpty(""))
|
||
})
|
||
|
||
it("returns false for non-empty string", () => {
|
||
assertFalse(S.isEmpty("a"))
|
||
assertFalse(S.isEmpty(" "))
|
||
})
|
||
})
|
||
|
||
describe("isNonEmpty", () => {
|
||
it("returns true for non-empty string", () => {
|
||
assertTrue(S.isNonEmpty("a"))
|
||
})
|
||
|
||
it("returns false for empty string", () => {
|
||
assertFalse(S.isNonEmpty(""))
|
||
})
|
||
})
|
||
|
||
describe("length", () => {
|
||
it("returns string length", () => {
|
||
strictEqual(S.length("abc"), 3)
|
||
})
|
||
|
||
it("returns 0 for empty string", () => {
|
||
strictEqual(S.length(""), 0)
|
||
})
|
||
})
|
||
|
||
describe("split", () => {
|
||
it("splits by string separator (data-last)", () => {
|
||
deepStrictEqual(pipe("a,b,c", S.split(",")), ["a", "b", "c"])
|
||
})
|
||
|
||
it("splits by string separator (data-first)", () => {
|
||
deepStrictEqual(S.split("hello,world", ","), ["hello", "world"])
|
||
})
|
||
|
||
it("splits by empty string", () => {
|
||
deepStrictEqual(pipe("abc", S.split("")), ["a", "b", "c"])
|
||
})
|
||
|
||
it("splits empty string by empty string", () => {
|
||
deepStrictEqual(pipe("", S.split("")), [""])
|
||
})
|
||
|
||
it("splits by regex", () => {
|
||
deepStrictEqual(pipe("a1b2c", S.split(/\d/)), ["a", "b", "c"])
|
||
})
|
||
})
|
||
|
||
describe("includes", () => {
|
||
it("returns true when substring found", () => {
|
||
assertTrue(pipe("hello world", S.includes("world")))
|
||
})
|
||
|
||
it("returns false when substring not found", () => {
|
||
assertFalse(pipe("hello world", S.includes("foo")))
|
||
})
|
||
|
||
it("starts searching at the given position", () => {
|
||
assertFalse(pipe("hello", S.includes("hel", 1)))
|
||
assertTrue(pipe("hello", S.includes("ell", 1)))
|
||
})
|
||
})
|
||
|
||
describe("startsWith", () => {
|
||
it("returns true when string starts with search", () => {
|
||
assertTrue(pipe("hello world", S.startsWith("hello")))
|
||
})
|
||
|
||
it("returns false when string does not start with search", () => {
|
||
assertFalse(pipe("hello world", S.startsWith("world")))
|
||
})
|
||
|
||
it("checks the prefix at the given position", () => {
|
||
assertTrue(pipe("hello world", S.startsWith("world", 6)))
|
||
})
|
||
})
|
||
|
||
describe("endsWith", () => {
|
||
it("returns true when string ends with search", () => {
|
||
assertTrue(pipe("hello world", S.endsWith("world")))
|
||
})
|
||
|
||
it("returns false when string does not end with search", () => {
|
||
assertFalse(pipe("hello world", S.endsWith("hello")))
|
||
})
|
||
|
||
it("checks the suffix at the given end position", () => {
|
||
assertTrue(pipe("hello world", S.endsWith("hello", 5)))
|
||
})
|
||
})
|
||
|
||
describe("charCodeAt", () => {
|
||
it("returns char code at index (data-first)", () => {
|
||
assertSome(S.charCodeAt("abc", 1), 98)
|
||
})
|
||
|
||
it("returns char code at index (data-last)", () => {
|
||
assertSome(pipe("abc", S.charCodeAt(0)), 97)
|
||
})
|
||
|
||
it("returns none for out of bounds", () => {
|
||
assertNone(S.charCodeAt("abc", 10))
|
||
})
|
||
})
|
||
|
||
describe("substring", () => {
|
||
it("extracts characters between indices", () => {
|
||
strictEqual(pipe("abcd", S.substring(1, 3)), "bc")
|
||
})
|
||
|
||
it("extracts from start to end", () => {
|
||
strictEqual(pipe("abcd", S.substring(1)), "bcd")
|
||
})
|
||
})
|
||
|
||
describe("at", () => {
|
||
it("returns character at index", () => {
|
||
assertSome(pipe("abc", S.at(1)), "b")
|
||
})
|
||
|
||
it("returns none for out of bounds", () => {
|
||
assertNone(pipe("abc", S.at(10)))
|
||
})
|
||
})
|
||
|
||
describe("charAt", () => {
|
||
it("returns character at index (data-first)", () => {
|
||
assertSome(S.charAt("abc", 1), "b")
|
||
})
|
||
|
||
it("returns character at index (data-last)", () => {
|
||
assertSome(pipe("abc", S.charAt(1)), "b")
|
||
})
|
||
|
||
it("returns none for out of bounds", () => {
|
||
assertNone(S.charAt("abc", 10))
|
||
})
|
||
})
|
||
|
||
describe("codePointAt", () => {
|
||
it("returns code point at index", () => {
|
||
assertSome(pipe("abc", S.codePointAt(1)), 98)
|
||
})
|
||
|
||
it("returns none for out of bounds", () => {
|
||
assertNone(pipe("abc", S.codePointAt(10)))
|
||
})
|
||
|
||
it("handles surrogate pairs", () => {
|
||
assertSome(pipe("𝟘", S.codePointAt(0)), 120792)
|
||
})
|
||
})
|
||
|
||
describe("indexOf", () => {
|
||
it("returns index of first occurrence", () => {
|
||
assertSome(pipe("abbbc", S.indexOf("b")), 1)
|
||
})
|
||
|
||
it("returns none when not found", () => {
|
||
assertNone(pipe("abbbc", S.indexOf("z")))
|
||
})
|
||
})
|
||
|
||
describe("lastIndexOf", () => {
|
||
it("returns index of last occurrence", () => {
|
||
assertSome(pipe("abbbc", S.lastIndexOf("b")), 3)
|
||
})
|
||
|
||
it("returns none when not found", () => {
|
||
assertNone(pipe("abbbc", S.lastIndexOf("z")))
|
||
})
|
||
})
|
||
|
||
describe("localeCompare", () => {
|
||
it("returns ordering", () => {
|
||
strictEqual(pipe("a", S.localeCompare("b")), -1)
|
||
strictEqual(pipe("b", S.localeCompare("a")), 1)
|
||
strictEqual(pipe("a", S.localeCompare("a")), 0)
|
||
})
|
||
})
|
||
|
||
describe("match", () => {
|
||
it("returns matched text and native match metadata", () => {
|
||
const result = pipe("hello", S.match(/l+/))
|
||
assert(Option.isSome(result))
|
||
strictEqual(result.value[0], "ll")
|
||
})
|
||
|
||
it("returns none when the pattern does not match", () => {
|
||
assertNone(pipe("hello", S.match(/x/)))
|
||
})
|
||
})
|
||
|
||
describe("matchAll", () => {
|
||
it("returns all matches", () => {
|
||
const result = Array.from(pipe("hello world", S.matchAll(/l/g)))
|
||
strictEqual(result.length, 3)
|
||
})
|
||
})
|
||
|
||
describe("normalize", () => {
|
||
it("normalizes with different forms", () => {
|
||
const str = "\u1E9B\u0323"
|
||
strictEqual(pipe(str, S.normalize("NFD")), "\u017F\u0323\u0307")
|
||
strictEqual(pipe(str, S.normalize("NFKC")), "\u1E69")
|
||
strictEqual(pipe(str, S.normalize("NFKD")), "\u0073\u0323\u0307")
|
||
})
|
||
})
|
||
|
||
describe("padEnd", () => {
|
||
it("pads from end with spaces", () => {
|
||
strictEqual(pipe("a", S.padEnd(5)), "a ")
|
||
})
|
||
|
||
it("pads from end with fill string", () => {
|
||
strictEqual(pipe("a", S.padEnd(5, "_")), "a____")
|
||
})
|
||
|
||
it("does not truncate if already longer", () => {
|
||
strictEqual(pipe("hello", S.padEnd(3)), "hello")
|
||
})
|
||
})
|
||
|
||
describe("padStart", () => {
|
||
it("pads from start with spaces", () => {
|
||
strictEqual(pipe("a", S.padStart(5)), " a")
|
||
})
|
||
|
||
it("pads from start with fill string", () => {
|
||
strictEqual(pipe("a", S.padStart(5, "_")), "____a")
|
||
})
|
||
|
||
it("does not truncate if already longer", () => {
|
||
strictEqual(pipe("hello", S.padStart(3)), "hello")
|
||
})
|
||
})
|
||
|
||
describe("repeat", () => {
|
||
it("repeats the string", () => {
|
||
strictEqual(pipe("ab", S.repeat(3)), "ababab")
|
||
})
|
||
|
||
it("returns empty for 0 repeats", () => {
|
||
strictEqual(pipe("ab", S.repeat(0)), "")
|
||
})
|
||
})
|
||
|
||
describe("replaceAll", () => {
|
||
it("replaces all occurrences with string", () => {
|
||
strictEqual(pipe("ababb", S.replaceAll("b", "c")), "acacc")
|
||
})
|
||
|
||
it("replaces all occurrences with regex", () => {
|
||
strictEqual(pipe("ababb", S.replaceAll(/b/g, "c")), "acacc")
|
||
})
|
||
})
|
||
|
||
describe("search", () => {
|
||
it("returns index on match (data-first)", () => {
|
||
assertSome(S.search("ababb", "b"), 1)
|
||
})
|
||
|
||
it("returns index on match (data-last)", () => {
|
||
assertSome(pipe("ababb", S.search("b")), 1)
|
||
})
|
||
|
||
it("returns none when not found", () => {
|
||
assertNone(S.search("ababb", "d"))
|
||
})
|
||
|
||
it("works with regex", () => {
|
||
assertSome(S.search("ababb", /bb/), 3)
|
||
})
|
||
})
|
||
|
||
describe("toLocaleLowerCase", () => {
|
||
it("converts to locale lowercase", () => {
|
||
strictEqual(pipe("ABC", S.toLocaleLowerCase()), "abc")
|
||
})
|
||
})
|
||
|
||
describe("toLocaleUpperCase", () => {
|
||
it("converts to locale uppercase", () => {
|
||
strictEqual(pipe("abc", S.toLocaleUpperCase()), "ABC")
|
||
})
|
||
})
|
||
|
||
describe("takeLeft", () => {
|
||
it("takes n characters from the start (data-first)", () => {
|
||
strictEqual(S.takeLeft("Hello World", 5), "Hello")
|
||
})
|
||
|
||
it("takes n characters from the start (data-last)", () => {
|
||
strictEqual(pipe("Hello World", S.takeLeft(5)), "Hello")
|
||
})
|
||
|
||
it("returns whole string if n > length", () => {
|
||
strictEqual(S.takeLeft("abc", 10), "abc")
|
||
})
|
||
|
||
it("returns empty string for n <= 0", () => {
|
||
strictEqual(S.takeLeft("abc", 0), "")
|
||
strictEqual(S.takeLeft("abc", -1), "")
|
||
})
|
||
})
|
||
|
||
describe("takeRight", () => {
|
||
it("takes n characters from the end (data-first)", () => {
|
||
strictEqual(S.takeRight("Hello World", 5), "World")
|
||
})
|
||
|
||
it("takes n characters from the end (data-last)", () => {
|
||
strictEqual(pipe("Hello World", S.takeRight(5)), "World")
|
||
})
|
||
|
||
it("returns whole string if n > length", () => {
|
||
strictEqual(S.takeRight("abc", 10), "abc")
|
||
})
|
||
|
||
it("returns empty string for n <= 0", () => {
|
||
strictEqual(S.takeRight("abc", 0), "")
|
||
strictEqual(S.takeRight("abc", -1), "")
|
||
})
|
||
})
|
||
|
||
describe("linesIterator", () => {
|
||
it("yields lines without separators", () => {
|
||
deepStrictEqual(Array.from(S.linesIterator("hello\nworld\n")), ["hello", "world"])
|
||
})
|
||
|
||
it("handles CRLF", () => {
|
||
deepStrictEqual(Array.from(S.linesIterator("a\r\nb\r\n")), ["a", "b"])
|
||
})
|
||
|
||
it("handles single line without newline", () => {
|
||
deepStrictEqual(Array.from(S.linesIterator("hello")), ["hello"])
|
||
})
|
||
|
||
it("handles empty string", () => {
|
||
deepStrictEqual(Array.from(S.linesIterator("")), [])
|
||
})
|
||
})
|
||
|
||
describe("linesWithSeparators", () => {
|
||
it("yields lines with separators", () => {
|
||
deepStrictEqual(Array.from(S.linesWithSeparators("hello\nworld\n")), ["hello\n", "world\n"])
|
||
})
|
||
|
||
it("handles CRLF", () => {
|
||
deepStrictEqual(Array.from(S.linesWithSeparators("a\r\nb\r\n")), ["a\r\n", "b\r\n"])
|
||
})
|
||
|
||
it("handles line without trailing newline", () => {
|
||
deepStrictEqual(Array.from(S.linesWithSeparators("hello")), ["hello"])
|
||
})
|
||
})
|
||
|
||
describe("stripMargin", () => {
|
||
it("strips | margin", () => {
|
||
strictEqual(S.stripMargin(" |hello\n |world"), "hello\nworld")
|
||
})
|
||
})
|
||
|
||
describe("stripMarginWith", () => {
|
||
it("strips custom margin character (data-first)", () => {
|
||
strictEqual(S.stripMarginWith(" #hello\n #world", "#"), "hello\nworld")
|
||
})
|
||
|
||
it("strips custom margin character (data-last)", () => {
|
||
strictEqual(pipe(" #hello\n #world", S.stripMarginWith("#")), "hello\nworld")
|
||
})
|
||
|
||
it("leaves lines without margin unchanged", () => {
|
||
strictEqual(S.stripMarginWith("no margin\n |yes", "|"), "no margin\nyes")
|
||
})
|
||
})
|
||
|
||
describe("snakeToCamel", () => {
|
||
it("converts snake_case to camelCase", () => {
|
||
strictEqual(S.snakeToCamel("hello_world"), "helloWorld")
|
||
strictEqual(S.snakeToCamel("foo_bar_baz"), "fooBarBaz")
|
||
})
|
||
|
||
it("handles single word", () => {
|
||
strictEqual(S.snakeToCamel("hello"), "hello")
|
||
})
|
||
})
|
||
|
||
describe("snakeToPascal", () => {
|
||
it("converts snake_case to PascalCase", () => {
|
||
strictEqual(S.snakeToPascal("hello_world"), "HelloWorld")
|
||
strictEqual(S.snakeToPascal("foo_bar_baz"), "FooBarBaz")
|
||
})
|
||
})
|
||
|
||
describe("snakeToKebab", () => {
|
||
it("converts snake_case to kebab-case", () => {
|
||
strictEqual(S.snakeToKebab("hello_world"), "hello-world")
|
||
strictEqual(S.snakeToKebab("foo_bar_baz"), "foo-bar-baz")
|
||
})
|
||
})
|
||
|
||
describe("camelToSnake", () => {
|
||
it("converts camelCase to snake_case", () => {
|
||
strictEqual(S.camelToSnake("helloWorld"), "hello_world")
|
||
strictEqual(S.camelToSnake("fooBarBaz"), "foo_bar_baz")
|
||
})
|
||
})
|
||
|
||
describe("pascalToSnake", () => {
|
||
it("converts PascalCase to snake_case", () => {
|
||
strictEqual(S.pascalToSnake("HelloWorld"), "hello_world")
|
||
strictEqual(S.pascalToSnake("FooBarBaz"), "foo_bar_baz")
|
||
})
|
||
})
|
||
|
||
describe("kebabToSnake", () => {
|
||
it("converts kebab-case to snake_case", () => {
|
||
strictEqual(S.kebabToSnake("hello-world"), "hello_world")
|
||
strictEqual(S.kebabToSnake("foo-bar-baz"), "foo_bar_baz")
|
||
})
|
||
})
|
||
|
||
describe("noCase", () => {
|
||
it("converts to space-separated lowercase by default", () => {
|
||
strictEqual(S.noCase("helloWorld"), "hello world")
|
||
strictEqual(S.noCase("HelloWorld"), "hello world")
|
||
})
|
||
|
||
it("data-last with options", () => {
|
||
strictEqual(pipe("helloWorld", S.noCase({ delimiter: "-" })), "hello-world")
|
||
})
|
||
|
||
it("handles underscores and hyphens", () => {
|
||
strictEqual(S.noCase("hello_world"), "hello world")
|
||
strictEqual(S.noCase("hello-world"), "hello world")
|
||
})
|
||
|
||
it("splits digit-letter boundaries", () => {
|
||
strictEqual(S.noCase("field2value"), "field 2 value")
|
||
strictEqual(S.noCase("field2Value"), "field 2 value")
|
||
})
|
||
})
|
||
|
||
describe("pascalCase", () => {
|
||
it("converts to PascalCase", () => {
|
||
strictEqual(S.pascalCase("hello world"), "HelloWorld")
|
||
strictEqual(S.pascalCase("hello_world"), "HelloWorld")
|
||
strictEqual(S.pascalCase("helloWorld"), "HelloWorld")
|
||
})
|
||
|
||
it("does not prefix numeric segments with underscores", () => {
|
||
strictEqual(S.pascalCase("foo 2 bar"), "Foo2Bar")
|
||
strictEqual(S.pascalCase("api-v2 xml"), "ApiV2Xml")
|
||
})
|
||
})
|
||
|
||
describe("camelCase", () => {
|
||
it("converts to camelCase", () => {
|
||
strictEqual(S.camelCase("hello world"), "helloWorld")
|
||
strictEqual(S.camelCase("hello_world"), "helloWorld")
|
||
strictEqual(S.camelCase("HelloWorld"), "helloWorld")
|
||
})
|
||
|
||
it("does not prefix numeric segments with underscores", () => {
|
||
strictEqual(S.camelCase("foo 2 bar"), "foo2Bar")
|
||
strictEqual(S.camelCase("api-v2 xml"), "apiV2Xml")
|
||
})
|
||
})
|
||
|
||
describe("constantCase", () => {
|
||
it("converts to CONSTANT_CASE", () => {
|
||
strictEqual(S.constantCase("hello world"), "HELLO_WORLD")
|
||
strictEqual(S.constantCase("helloWorld"), "HELLO_WORLD")
|
||
strictEqual(S.constantCase("api-v2 xml"), "API_V_2_XML")
|
||
})
|
||
})
|
||
|
||
describe("configCase", () => {
|
||
it("converts to CONFIG_CASE", () => {
|
||
strictEqual(S.configCase("hello world"), "HELLO_WORLD")
|
||
strictEqual(S.configCase("helloWorld"), "HELLO_WORLD")
|
||
strictEqual(S.configCase("api-v2 xml"), "API_V2_XML")
|
||
strictEqual(S.configCase("field2Value"), "FIELD2_VALUE")
|
||
})
|
||
})
|
||
|
||
describe("kebabCase", () => {
|
||
it("converts to kebab-case", () => {
|
||
strictEqual(S.kebabCase("hello world"), "hello-world")
|
||
strictEqual(S.kebabCase("helloWorld"), "hello-world")
|
||
})
|
||
})
|
||
|
||
describe("snakeCase", () => {
|
||
it("converts to snake_case", () => {
|
||
strictEqual(S.snakeCase("hello world"), "hello_world")
|
||
strictEqual(S.snakeCase("helloWorld"), "hello_world")
|
||
})
|
||
})
|
||
|
||
describe("ReducerConcat", () => {
|
||
it("combines strings", () => {
|
||
strictEqual(S.ReducerConcat.combine("a", "b"), "ab")
|
||
})
|
||
|
||
it("identity with initialValue", () => {
|
||
strictEqual(S.ReducerConcat.combine("a", S.ReducerConcat.initialValue), "a")
|
||
strictEqual(S.ReducerConcat.combine(S.ReducerConcat.initialValue, "a"), "a")
|
||
})
|
||
})
|
||
})
|