Merge pull request #6 from payid-org/misc

Add actual utility functions to use for implementing PayID-specific functions.

Context:
Both the PayID server and the Xpring SDK have this isAscii function, and it seems like a isValidUrl function would be useful as well.

Author: 0xCLARITY

package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "payid-utils",
+  "name": "@payid-org/payid-utils",
   "version": "0.1.0",
   "description": "A TypeScript library providing PayID utility functions",
   "homepage": "https://github.com/payid-org/payid-utils#readme",
@@ -26,11 +26,13 @@
   "devDependencies": {
     "@arkweid/lefthook": "^0.7.2",
     "@fintechstudios/eslint-plugin-chai-as-promised": "^3.0.2",
+    "@types/chai": "^4.2.11",
     "@types/mocha": "^7.0.2",
     "@types/node": "^14.0.14",
     "@typescript-eslint/eslint-plugin": "^3.5.0",
     "@typescript-eslint/parser": "^3.5.0",
     "@xpring-eng/eslint-config-base": "^0.9.0",
+    "chai": "^4.2.0",
     "eslint": "^7.3.1",
     "eslint-plugin-array-func": "^3.1.6",
     "eslint-plugin-eslint-comments": "^3.2.0",

package.json

@@ -0,0 +1,37 @@
+/**
+ * Validate if the input is ASCII based text.
+ *
+ * Shamelessly taken from:
+ * https://stackoverflow.com/questions/14313183/javascript-regex-how-do-i-check-if-the-string-is-ascii-only.
+ *
+ * @param input - The input to check.
+ *
+ * @returns A boolean indicating the result.
+ */
+export function isAscii(input: string): boolean {
+  // eslint-disable-next-line no-control-regex -- The ASCII regex uses control characters
+  return /^[\x00-\x7F]*$/u.test(input)
+}
+
+/**
+ * Validate if the given input is a valid URL.
+ *
+ * @param input - A string that may or may not be a valid URL.
+ *
+ * @returns A boolean indicating whether or not the input string was a valid URL.
+ */
+export function isValidUrl(input: string): boolean {
+  // Check that there is at least the possibility of a TLD existing
+  if (!input.includes('.')) {
+    return false
+  }
+
+  try {
+    // eslint-disable-next-line no-new -- Explicitly using new URL to see if a TypeError is thrown.
+    new URL(input)
+  } catch {
+    return false
+  }
+
+  return true
+}

src/.gitkeep

@@ -0,0 +1,28 @@
+import 'mocha'
+import { assert } from 'chai'
+
+import { isAscii } from '../../../src/utils'
+
+describe('isAscii()', function (): void {
+  it('Returns true for a string that is all ASCII', function () {
+    // GIVEN an ASCII string
+    const asciiString = 'johndoe'
+
+    // WHEN the string is determined to be ASCII
+    const isStringAscii = isAscii(asciiString)
+
+    // THEN we expect to get true back
+    assert.strictEqual(isStringAscii, true)
+  })
+
+  it('Returns false for a string that contains non-ASCII characters', function () {
+    // GIVEN an non-ASCII string
+    const nonAsciiString = 'example.网络'
+
+    // WHEN we see if the string is ASCII
+    const isStringAscii = isAscii(nonAsciiString)
+
+    // THEN we expect to get false back
+    assert.strictEqual(isStringAscii, false)
+  })
+})

src/utils.ts

@@ -0,0 +1,39 @@
+import 'mocha'
+import { assert } from 'chai'
+
+import { isValidUrl } from '../../../src/utils'
+
+describe('isValidUrl()', function (): void {
+  it('Returns true for a string that is a valid URL', function () {
+    // GIVEN a valid URL string
+    const validUrl = 'https://example.com'
+
+    // WHEN we see if the URL string is a valid URL
+    const isUrlValid = isValidUrl(validUrl)
+
+    // THEN we expect to get true back
+    assert.strictEqual(isUrlValid, true)
+  })
+
+  it('Returns false for a URL without a protocol', async function () {
+    // GIVEN an URL without a protocol
+    const invalidUrl = 'example.com'
+
+    // WHEN we see if the string is a valid URL
+    const isUrlValid = isValidUrl(invalidUrl)
+
+    // THEN we expect to get false back
+    assert.strictEqual(isUrlValid, false)
+  })
+
+  it('Returns false for a URL without a TLD', async function () {
+    // GIVEN an URL without a TLD
+    const invalidUrl = 'https://example'
+
+    // WHEN we see if the string is a valid URL
+    const isUrlValid = isValidUrl(invalidUrl)
+
+    // THEN we expect to get false back
+    assert.strictEqual(isUrlValid, false)
+  })
+})