opticedge-cloud-utils 1.1.3 → 1.1.5

package/dist/index.d.ts

@@ -5,6 +5,7 @@ export * from './tw/utils';
 export * from './tw/wallet';
 export * from './auth';
 export * from './env';
+export * from './parser';
 export * from './regex';
 export * from './secrets';
 export * from './task';

package/dist/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./tw/utils"), exports);
 __exportStar(require("./tw/wallet"), exports);
 __exportStar(require("./auth"), exports);
 __exportStar(require("./env"), exports);
+__exportStar(require("./parser"), exports);
 __exportStar(require("./regex"), exports);
 __exportStar(require("./secrets"), exports);
 __exportStar(require("./task"), exports);

package/dist/parser.d.ts

@@ -0,0 +1,2 @@
+declare const toNumber: (v: any) => number | null;
+export { toNumber };

package/dist/parser.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNumber = void 0;
+// Helper: accept number or numeric-string, return number or null
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const toNumber = (v) => {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && /^\d+$/.test(v))
+        return Number(v);
+    return null;
+};
+exports.toNumber = toNumber;

package/dist/regex.d.ts

@@ -1 +1,12 @@
-export declare function escapeForRegex(input: string): string;
+/**
+ * Escape user input so it can be safely used as a regex pattern string.
+ *
+ * - Escapes regex metacharacters.
+ * - Replaces any run of whitespace with the token `\s+` so searches tolerate variable whitespace.
+ * - Caps input length to avoid pathological long-input ReDoS vectors (default cap = 100).
+ *
+ * @param input - user-provided string to escape
+ * @param maxLength - maximum number of characters to consider from input (default 100)
+ * @returns a safe regex pattern string (do NOT wrap with // when passing to Mongo $regex)
+ */
+export declare function escapeForRegex(input: string, maxLength?: number): string;

package/dist/regex.js

@@ -1,6 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeForRegex = escapeForRegex;
-function escapeForRegex(input) {
-    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * Escape user input so it can be safely used as a regex pattern string.
+ *
+ * - Escapes regex metacharacters.
+ * - Replaces any run of whitespace with the token `\s+` so searches tolerate variable whitespace.
+ * - Caps input length to avoid pathological long-input ReDoS vectors (default cap = 100).
+ *
+ * @param input - user-provided string to escape
+ * @param maxLength - maximum number of characters to consider from input (default 100)
+ * @returns a safe regex pattern string (do NOT wrap with // when passing to Mongo $regex)
+ */
+function escapeForRegex(input, maxLength = 100) {
+    const safeStr = String(input ?? '');
+    const capped = safeStr.length > maxLength ? safeStr.slice(0, maxLength) : safeStr;
+    // escape regex metacharacters: . * + ? ^ $ { } ( ) | [ ] \ /
+    const escaped = capped.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // convert any whitespace run to the regex token \s+ (as a string)
+    return escaped.replace(/\s+/g, '\\s+');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opticedge-cloud-utils",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Common utilities for cloud functions",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './tw/utils'
 export * from './tw/wallet'
 export * from './auth'
 export * from './env'
+export * from './parser'
 export * from './regex'
 export * from './secrets'
 export * from './task'

package/src/parser.ts

@@ -0,0 +1,9 @@
+// Helper: accept number or numeric-string, return number or null
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const toNumber = (v: any): number | null => {
+  if (typeof v === 'number' && Number.isFinite(v)) return v
+  if (typeof v === 'string' && /^\d+$/.test(v)) return Number(v)
+  return null
+}
+
+export { toNumber }

package/src/regex.ts

@@ -1,3 +1,19 @@
-export function escapeForRegex(input: string): string {
-  return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+/**
+ * Escape user input so it can be safely used as a regex pattern string.
+ *
+ * - Escapes regex metacharacters.
+ * - Replaces any run of whitespace with the token `\s+` so searches tolerate variable whitespace.
+ * - Caps input length to avoid pathological long-input ReDoS vectors (default cap = 100).
+ *
+ * @param input - user-provided string to escape
+ * @param maxLength - maximum number of characters to consider from input (default 100)
+ * @returns a safe regex pattern string (do NOT wrap with // when passing to Mongo $regex)
+ */
+export function escapeForRegex(input: string, maxLength = 100): string {
+  const safeStr = String(input ?? '')
+  const capped = safeStr.length > maxLength ? safeStr.slice(0, maxLength) : safeStr
+  // escape regex metacharacters: . * + ? ^ $ { } ( ) | [ ] \ /
+  const escaped = capped.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  // convert any whitespace run to the regex token \s+ (as a string)
+  return escaped.replace(/\s+/g, '\\s+')
 }

package/tests/parser.test.ts

@@ -0,0 +1,26 @@
+import { toNumber } from '../src'
+
+describe('toNumber', () => {
+  it('returns the same number when input is a finite number', () => {
+    expect(toNumber(123)).toBe(123)
+    expect(toNumber(0)).toBe(0)
+  })
+
+  it('returns number when input is a numeric string', () => {
+    expect(toNumber('456')).toBe(456)
+  })
+
+  it('returns null for non-numeric strings', () => {
+    expect(toNumber('abc')).toBeNull()
+    expect(toNumber('123abc')).toBeNull()
+    expect(toNumber('')).toBeNull()
+  })
+
+  it('returns null for non-numbers', () => {
+    expect(toNumber(NaN)).toBeNull()
+    expect(toNumber(Infinity)).toBeNull()
+    expect(toNumber(undefined)).toBeNull()
+    expect(toNumber(null)).toBeNull()
+    expect(toNumber({})).toBeNull()
+  })
+})

package/tests/regex.test.ts

@@ -1,24 +1,69 @@
+// tests/regex.test.ts
 import { escapeForRegex } from '../src/regex'
 
-describe('escapeRegex', () => {
-  it('escapes regex special characters', () => {
+describe('escapeForRegex', () => {
+  it('escapes regex special characters (including backslash)', () => {
     const input = 'Pikachu.$^*+?()[]{}|\\'
     const expected = 'Pikachu\\.\\$\\^\\*\\+\\?\\(\\)\\[\\]\\{\\}\\|\\\\'
     expect(escapeForRegex(input)).toBe(expected)
   })
 
-  it('returns same string if no special characters', () => {
+  it('replaces whitespace runs with \\s+ and escapes other metachars', () => {
+    const input = 'Charizard (Holo   Rare)' // multiple spaces inside
+    const expected = 'Charizard\\s+\\(Holo\\s+Rare\\)'
+    expect(escapeForRegex(input)).toBe(expected)
+  })
+
+  it('leaves plain alphanumerics unchanged', () => {
     const input = 'Charmander123'
     expect(escapeForRegex(input)).toBe('Charmander123')
   })
 
-  it('works with empty string', () => {
+  it('converts tabs and single spaces to \\s+ and escapes dots', () => {
+    const input = 'Lt. Surge\tPikachu'
+    const expected = 'Lt\\.\\s+Surge\\s+Pikachu'
+    expect(escapeForRegex(input)).toBe(expected)
+  })
+
+  it('truncates input when maxLength is passed', () => {
+    const long = 'a'.repeat(200)
+    // override maxLength to 50 for this test
+    expect(escapeForRegex(long, 50)).toBe('a'.repeat(50))
+  })
+
+  it('applies default cap of 100 characters when input is longer and contains no metachars', () => {
+    const long = 'b'.repeat(150)
+    const out = escapeForRegex(long) // default cap = 100
+    expect(out).toBe('b'.repeat(100))
+    expect(out.length).toBe(100)
+  })
+
+  it('handles empty string', () => {
     expect(escapeForRegex('')).toBe('')
   })
 
-  it('does not escape regular alphanumerics or spaces', () => {
-    const input = 'Lt. Surge Pikachu'
-    const expected = 'Lt\\. Surge Pikachu'
-    expect(escapeForRegex(input)).toBe(expected)
+  // -----------------------------
+  // NEW: coverage for safeStr branch
+  // -----------------------------
+  it('handles undefined input (covers input ?? "")', () => {
+    // call with undefined; TypeScript may complain so cast to any in test
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(undefined as any)).toBe('')
+  })
+
+  it('handles null input (covers input ?? "")', () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(null as any)).toBe('')
+  })
+
+  it('coerces non-string input to string and escapes metachars if present', () => {
+    // number becomes "42"
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    expect(escapeForRegex(42 as any)).toBe('42')
+
+    // object coerces to "[object Object]" and special chars will be escaped if present
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const objInput = { toString: () => 'X(1) Y' } as any
+    expect(escapeForRegex(objInput)).toBe('X\\(1\\)\\s+Y')
   })
 })