feat(internal): validateString

Signed-off-by: Lexus Drumgold <unicornware@flexdevelopment.llc>

Author: unicornware

src/internal/__tests__/validate-string.spec-d.ts

@@ -0,0 +1,12 @@
+/**
+ * @file Type Tests - validateString
+ * @module ext-regex/internal/tests/unit-d/validateString
+ */
+
+import type testSubject from '../validate-string'
+
+describe('unit-d:internal/validateString', () => {
+  it('should guard string', () => {
+    expectTypeOf<typeof testSubject>().guards.toBeString()
+  })
+})

src/internal/__tests__/validate-string.spec.ts

@@ -0,0 +1,36 @@
+/**
+ * @file Unit Tests - validateString
+ * @module ext-regex/internal/tests/unit/validateString
+ */
+
+import { ErrorCode, type NodeError } from '@flex-development/errnode'
+import testSubject from '../validate-string'
+
+describe('unit:internal/validateString', () => {
+  let name: string
+
+  beforeEach(() => {
+    name = 'ext'
+  })
+
+  it('should return true if value is typeof string', () => {
+    expect(testSubject('.mjs', name)).to.be.true
+  })
+
+  it('should throw if value is not typeof string', () => {
+    // Arrange
+    const code: ErrorCode = ErrorCode.ERR_INVALID_ARG_TYPE
+    let error: NodeError<TypeError>
+
+    // Act
+    try {
+      testSubject(null, name)
+    } catch (e: unknown) {
+      error = e as typeof error
+    }
+
+    // Expect
+    expect(error!).to.be.instanceof(TypeError)
+    expect(error!).to.have.property('code').equal(code)
+  })
+})

src/internal/index.ts

@@ -0,0 +1,6 @@
+/**
+ * @file Entry Point - Internal
+ * @module ext-regex/internal
+ */
+
+export { default as validateString } from './validate-string'

src/internal/validate-string.ts

@@ -0,0 +1,28 @@
+/**
+ * @file Internal - validateString
+ * @module ext-regex/internal/validateString
+ */
+
+import * as errnode from '@flex-development/errnode'
+
+/**
+ * Checks if given `value` is a string.
+ *
+ * Throws [`ERR_INVALID_ARG_TYPE`][1] if the `value` is not a string.
+ *
+ * [1]: https://nodejs.org/api/errors.html#err_invalid_arg_value
+ *
+ * @see {@linkcode errnode.ERR_INVALID_ARG_TYPE}
+ * @see {@linkcode errnode.NodeError}
+ *
+ * @param {unknown} value - Value supplied by user
+ * @param {string} name - Name of invalid argument or property
+ * @return {value is string} `true` if `value` is a string
+ * @throws {errnode.NodeError<TypeError>} If `value` is not a string
+ */
+const validateString = (value: unknown, name: string): value is string => {
+  if (typeof value === 'string') return true
+  throw new errnode.ERR_INVALID_ARG_TYPE(name, 'string', value)
+}
+
+export default validateString