@ezez/utils 1.0.0 → 1.1.0

package/src/isNumericString.ts

@@ -0,0 +1,94 @@
+interface Options {
+    allowFloats?: boolean;
+    allowExponents?: boolean;
+    allowInfinity?: boolean;
+    allowNaN?: boolean;
+}
+
+const NOT_FOUND = -1;
+
+/**
+ * Checks if a string is a numeric string. By default, it allows only integers. Floats and exponents can be enabled with
+ * options. Optionally allow NaN and Infinity.
+ * @param {string} string - String to check
+ * @param {object} [options] - Options object
+ * @param {boolean} [options.allowFloats=false] - Allow floats
+ * @param {boolean} [options.allowExponents=false] - Allow exponents
+ * @param {boolean} [options.allowInfinity=false] - Allow Initity and -Infinity (casing matters)
+ * @param {boolean} [options.allowNaN=false] - Allow NaN (casing matters)
+ */
+const isNumericString = (string: string, options: Options = {}) => { // eslint-disable-line max-statements, max-lines-per-function, max-len
+    if (typeof string !== "string") {
+        throw new TypeError("Expected a string");
+    }
+
+    if (options.allowNaN && string === "NaN") {
+        return true;
+    }
+
+    if (options.allowInfinity && (string === "Infinity" || string === "-Infinity")) {
+        return true;
+    }
+
+    let normalized = string.toLowerCase();
+    if (normalized.startsWith("-")) {
+        normalized = normalized.slice(1);
+    }
+
+    const parts = normalized.split(".");
+
+    // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+    if (parts.length > (options.allowFloats ? 2 : 1)) {
+        return false;
+    }
+
+    const expParts = parts[parts.length - 1].split("e");
+
+    if (!options.allowExponents) {
+        if (expParts.length > 1) {
+            return false;
+        }
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/no-magic-numbers
+        if (expParts.length > 2) {
+            return false;
+        }
+    }
+
+    const hasPlusAt = normalized.indexOf("+");
+    if (hasPlusAt > NOT_FOUND) {
+        if (!options.allowExponents) {
+            return false;
+        }
+        if (hasPlusAt !== normalized.lastIndexOf("+")) {
+            return false;
+        }
+        if (hasPlusAt !== normalized.indexOf("e") + 1) {
+            return false;
+        }
+    }
+
+    const hasMinusAt = normalized.indexOf("-");
+    if (hasMinusAt > NOT_FOUND) {
+        if (!options.allowExponents) {
+            return false;
+        }
+        if (hasMinusAt !== normalized.lastIndexOf("-")) {
+            return false;
+        }
+        if (hasMinusAt !== normalized.indexOf("e") + 1) {
+            return false;
+        }
+    }
+
+    return Boolean(/^[\de.+-]+$/.exec(normalized));
+};
+
+export {
+    isNumericString,
+};
+
+export type {
+    Options as IsNumericStringOptions,
+};

package/src/occurrences.spec.ts

@@ -0,0 +1,20 @@
+import { occurrences } from "./occurrences.js";
+
+describe("occurrences", function() {
+    it("returns zero for empty search string", function() {
+        occurrences("test string", "").must.equal(0);
+    });
+
+    it("returns count of occurences for typical use cases", function() {
+        occurrences("hello beautiful world, hello bees and hello sun", "hello").must.equal(3);
+        occurrences("hello beautiful world, hello bees and hello sun", "o").must.equal(4);
+    });
+
+    it("allows counting overlaps too", function() {
+        occurrences("aaaa", "aa", { overlap: true }).must.equal(3);
+        occurrences("aaaa", "aa", { overlap: false }).must.equal(2);
+
+        occurrences("aaaaaa", "aa", { overlap: true }).must.equal(5);
+        occurrences("aaaaaa", "aa", { overlap: false }).must.equal(3);
+    });
+});

package/src/occurrences.ts

@@ -0,0 +1,53 @@
+interface Options {
+    /**
+     * Allow overlapping matches, ie. "aa" in "aaa" will return 2 instead of 1
+     */
+    overlap?: boolean;
+}
+
+const NOT_FOUND = -1;
+
+/**
+ * Count the number of occurrences of a substring in a string
+ *
+ * @example occurrences("aaa", "a"); // 3
+ * @example occurrences("aaaa", "aa", { overlap: false }); // 2
+ * @example occurrences("aaaa", "aa", { overlap: true }); // 3
+ * @param {string} string - string to search in
+ * @param {string} search - string to search for
+ * @param {object} [options] - options
+ * @param {boolean} [options.overlap=false] - allow overlapping matches, ie "aa" in "aaa" will return 2 instead of 1
+ */
+const occurrences = (string: string, search: string, { overlap }: Options = {}) => {
+    if (typeof string !== "string") {
+        throw new TypeError("Expected a string");
+    }
+    if (typeof search !== "string") {
+        throw new TypeError("Expected a string");
+    }
+    if (search.length === 0) {
+        return 0;
+    }
+    let n = 0,
+        i = 0;
+
+    // eslint-disable-next-line no-constant-condition,@typescript-eslint/no-unnecessary-condition
+    while (true) {
+        i = string.indexOf(search, i);
+
+        if (i === NOT_FOUND) {
+            break;
+        }
+        n++;
+        i += overlap ? 1 : search.length;
+    }
+    return n;
+};
+
+export {
+    occurrences,
+};
+
+export type {
+    Options as OccurencesOptions,
+};