core-services-sdk 1.3.11 → 1.3.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.3.11",
+  "version": "1.3.13",
   "main": "src/index.js",
   "type": "module",
   "scripts": {

package/src/core/normalize-phone-number.js

@@ -1,12 +1,40 @@
-// src/core/phone-validate.js
-// Validate & normalize using google-libphonenumber
+// normalize-phone-number.js
+// Works with both CJS and ESM builds of google-libphonenumber
 
-import { PhoneNumberUtil, PhoneNumberFormat } from 'google-libphonenumber'
+import * as raw from 'google-libphonenumber'
 
-const phoneUtil = PhoneNumberUtil.getInstance()
+/** Resolve libphonenumber regardless of interop shape */
+function getLib() {
+  // Prefer direct (CJS-style or ESM w/ named), else default
+  // e.g. raw.PhoneNumberUtil OR raw.default.PhoneNumberUtil
+  // eslint-disable-next-line no-unused-vars
+  /** @type {any} */
+  const anyRaw = raw
+  const lib = anyRaw.PhoneNumberUtil ? anyRaw : anyRaw.default ?? anyRaw
+
+  if (!lib || !lib.PhoneNumberUtil || !lib.PhoneNumberFormat) {
+    throw new Error('google-libphonenumber failed to load (exports not found)')
+  }
+  return lib
+}
+
+let _util // lazy singleton
+
+function phoneUtil() {
+  if (!_util) {
+    const { PhoneNumberUtil } = getLib()
+    _util = PhoneNumberUtil.getInstance()
+  }
+  return _util
+}
+
+function formats() {
+  const { PhoneNumberFormat } = getLib()
+  return PhoneNumberFormat
+}
 
 /**
- * Trim and remove invisible RTL markers that can sneak in from copy/paste.
+ * Trim and remove invisible RTL markers.
  * @param {string} input
  * @returns {string}
  */
@@ -18,53 +46,57 @@ function clean(input) {
 
 /**
  * Convert a parsed libphonenumber object into a normalized result.
- * @param {import('google-libphonenumber').PhoneNumber} parsed
+ * @param {any} parsed
  * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
  */
 function toResult(parsed) {
+  const PNF = formats()
+  const util = phoneUtil()
   return {
-    e164: phoneUtil.format(parsed, PhoneNumberFormat.E164),
-    national: phoneUtil.format(parsed, PhoneNumberFormat.NATIONAL),
-    international: phoneUtil.format(parsed, PhoneNumberFormat.INTERNATIONAL),
-    regionCode: phoneUtil.getRegionCodeForNumber(parsed),
-    type: phoneUtil.getNumberType(parsed),
+    e164: util.format(parsed, PNF.E164),
+    national: util.format(parsed, PNF.NATIONAL),
+    international: util.format(parsed, PNF.INTERNATIONAL),
+    regionCode: util.getRegionCodeForNumber(parsed),
+    type: util.getNumberType(parsed),
   }
 }
 
 /**
  * Parse & validate an international number (must start with '+').
- * Throws on invalid input.
- *
- * @param {string} input - International number, e.g. "+972541234567"
+ * @param {string} input
  * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
  * @throws {Error} If the number is invalid
  */
 export function normalizePhoneOrThrowIntl(input) {
   try {
-    const parsed = phoneUtil.parseAndKeepRawInput(clean(input))
-    if (!phoneUtil.isValidNumber(parsed)) throw new Error('x')
+    const util = phoneUtil()
+    const parsed = util.parseAndKeepRawInput(clean(input))
+    if (!util.isValidNumber(parsed)) throw new Error('x')
     return toResult(parsed)
-  } catch {
-    throw new Error('Invalid phone number')
+  } catch (e) {
+    const err = new Error('Invalid phone number')
+    err.cause = e
+    throw err
   }
 }
 
 /**
  * Parse & validate a national number using a region hint.
- * Throws on invalid input.
- *
- * @param {string} input - National number, e.g. "054-123-4567"
- * @param {string} defaultRegion - ISO region like "IL" or "US"
+ * @param {string} input
+ * @param {string} defaultRegion
  * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
  * @throws {Error} If the number is invalid
  */
 export function normalizePhoneOrThrowWithRegion(input, defaultRegion) {
   try {
-    const parsed = phoneUtil.parseAndKeepRawInput(clean(input), defaultRegion)
-    if (!phoneUtil.isValidNumber(parsed)) throw new Error('x')
+    const util = phoneUtil()
+    const parsed = util.parseAndKeepRawInput(clean(input), defaultRegion)
+    if (!util.isValidNumber(parsed)) throw new Error('x')
     return toResult(parsed)
-  } catch {
-    throw new Error('Invalid phone number')
+  } catch (e) {
+    const err = new Error('Invalid phone number')
+    err.cause = e
+    throw err
   }
 }
 
@@ -72,8 +104,6 @@ export function normalizePhoneOrThrowWithRegion(input, defaultRegion) {
  * Smart normalization:
  * - If input starts with '+', parse as international.
  * - Otherwise require a defaultRegion and parse as national.
- * Throws on invalid input or when defaultRegion is missing for non-international numbers.
- *
  * @param {string} input
  * @param {{ defaultRegion?: string }} [opts]
  * @returns {{e164:string,national:string,international:string,regionCode:string|undefined,type:number}}
@@ -86,7 +116,6 @@ export function normalizePhoneOrThrow(input, opts = {}) {
   }
   const { defaultRegion } = opts
   if (!defaultRegion) {
-    // keep this one specific; your test relies on a different message here
     throw new Error('defaultRegion is required for non-international numbers')
   }
   return normalizePhoneOrThrowWithRegion(cleaned, defaultRegion)

package/tests/core/normalize-phone-number.unit.test.js

@@ -22,94 +22,95 @@ function exampleForRegion(region) {
     region,
   }
 }
+describe('phone normalization', () => {
+  describe('phone normalization helpers', () => {
+    it('normalizePhoneOrThrowIntl: parses a valid international number (US)', () => {
+      const us = exampleForRegion('US')
+      const out = normalizePhoneOrThrowIntl(us.e164)
+      expect(out.e164).toBe(us.e164)
+      expect(out.regionCode).toBe('US')
+      expect(out.international).toMatch(/^\+1\b/)
+    })
 
-describe('phone normalization helpers', () => {
-  it('normalizePhoneOrThrowIntl: parses a valid international number (US)', () => {
-    const us = exampleForRegion('US')
-    const out = normalizePhoneOrThrowIntl(us.e164)
-    expect(out.e164).toBe(us.e164)
-    expect(out.regionCode).toBe('US')
-    expect(out.international).toMatch(/^\+1\b/)
-  })
-
-  it('normalizePhoneOrThrowWithRegion: parses a national number with region (IL)', () => {
-    const il = exampleForRegion('IL')
-    // introduce some separators/spaces to mimic user input
-    const dirty = `  ${il.national.replace(/\s/g, '-')}  `
-    const out = normalizePhoneOrThrowWithRegion(dirty, 'IL')
-    expect(out.e164).toBe(il.e164)
-    expect(out.regionCode).toBe('IL')
-    expect(out.international).toMatch(/^\+972/)
-  })
+    it('normalizePhoneOrThrowWithRegion: parses a national number with region (IL)', () => {
+      const il = exampleForRegion('IL')
+      // introduce some separators/spaces to mimic user input
+      const dirty = `  ${il.national.replace(/\s/g, '-')}  `
+      const out = normalizePhoneOrThrowWithRegion(dirty, 'IL')
+      expect(out.e164).toBe(il.e164)
+      expect(out.regionCode).toBe('IL')
+      expect(out.international).toMatch(/^\+972/)
+    })
 
-  it('normalizePhoneOrThrow (smart): international path without region', () => {
-    const us = exampleForRegion('US')
-    const out = normalizePhoneOrThrow(us.e164)
-    expect(out.e164).toBe(us.e164)
-    expect(out.regionCode).toBe('US')
-  })
+    it('normalizePhoneOrThrow (smart): international path without region', () => {
+      const us = exampleForRegion('US')
+      const out = normalizePhoneOrThrow(us.e164)
+      expect(out.e164).toBe(us.e164)
+      expect(out.regionCode).toBe('US')
+    })
 
-  it('normalizePhoneOrThrow (smart): national path requires defaultRegion', () => {
-    const il = exampleForRegion('IL')
-    const dirty = il.national.replace(/\s/g, ' - ')
-    const out = normalizePhoneOrThrow(dirty, { defaultRegion: 'IL' })
-    expect(out.e164).toBe(il.e164)
-    expect(out.regionCode).toBe('IL')
-  })
+    it('normalizePhoneOrThrow (smart): national path requires defaultRegion', () => {
+      const il = exampleForRegion('IL')
+      const dirty = il.national.replace(/\s/g, ' - ')
+      const out = normalizePhoneOrThrow(dirty, { defaultRegion: 'IL' })
+      expect(out.e164).toBe(il.e164)
+      expect(out.regionCode).toBe('IL')
+    })
 
-  it('normalizePhoneOrThrow (smart): throws if national with no defaultRegion', () => {
-    expect(() => normalizePhoneOrThrow('054-123-4567')).toThrow(
-      /defaultRegion is required/i,
-    )
-  })
+    it('normalizePhoneOrThrow (smart): throws if national with no defaultRegion', () => {
+      expect(() => normalizePhoneOrThrow('054-123-4567')).toThrow(
+        /defaultRegion is required/i,
+      )
+    })
 
-  it('all helpers: throw on truly invalid numbers', () => {
-    expect(() => normalizePhoneOrThrowIntl('++972')).toThrow(
-      /Invalid phone number/i,
-    )
-    expect(() => normalizePhoneOrThrowWithRegion('123', 'IL')).toThrow(
-      /Invalid phone number/i,
-    )
-    expect(() => normalizePhoneOrThrow('++972')).toThrow(
-      /Invalid phone number/i,
-    )
-  })
+    it('all helpers: throw on truly invalid numbers', () => {
+      expect(() => normalizePhoneOrThrowIntl('++972')).toThrow(
+        /Invalid phone number/i,
+      )
+      expect(() => normalizePhoneOrThrowWithRegion('123', 'IL')).toThrow(
+        /Invalid phone number/i,
+      )
+      expect(() => normalizePhoneOrThrow('++972')).toThrow(
+        /Invalid phone number/i,
+      )
+    })
 
-  it('should normalize a valid international number', () => {
-    const result = normalizePhoneOrThrowIntl('+972523444444')
+    it('should normalize a valid international number', () => {
+      const result = normalizePhoneOrThrowIntl('+972523444444')
 
-    expect(result).toMatchObject({
-      e164: '+972523444444',
-      national: expect.stringContaining('052'),
-      international: expect.stringContaining('+972'),
-      regionCode: 'IL',
-      type: expect.any(Number), // e.g. 1 = MOBILE
+      expect(result).toMatchObject({
+        e164: '+972523444444',
+        national: expect.stringContaining('052'),
+        international: expect.stringContaining('+972'),
+        regionCode: 'IL',
+        type: expect.any(Number), // e.g. 1 = MOBILE
+      })
     })
   })
-})
 
-describe('phone normalization — no region (international) & with region', () => {
-  // Valid full international IL mobile number (E.164)
-  const intlIl = '+972523444444' // 052-344-4444
+  describe('phone normalization — no region (international) & with region', () => {
+    // Valid full international IL mobile number (E.164)
+    const intlIl = '+972523444444' // 052-344-4444
 
-  it('normalizePhoneOrThrowIntl: accepts full international number without region', () => {
-    const out = normalizePhoneOrThrowIntl(intlIl)
-    expect(out.e164).toBe(intlIl)
-    expect(out.regionCode).toBe('IL')
-    expect(out.international).toMatch(/^\+972/)
-    expect(typeof out.type).toBe('number')
-  })
+    it('normalizePhoneOrThrowIntl: accepts full international number without region', () => {
+      const out = normalizePhoneOrThrowIntl(intlIl)
+      expect(out.e164).toBe(intlIl)
+      expect(out.regionCode).toBe('IL')
+      expect(out.international).toMatch(/^\+972/)
+      expect(typeof out.type).toBe('number')
+    })
 
-  it('normalizePhoneOrThrow (smart): accepts +972... without defaultRegion', () => {
-    const out = normalizePhoneOrThrow(intlIl) // no opts.defaultRegion
-    expect(out.e164).toBe(intlIl)
-    expect(out.regionCode).toBe('IL')
-  })
+    it('normalizePhoneOrThrow (smart): accepts +972... without defaultRegion', () => {
+      const out = normalizePhoneOrThrow(intlIl) // no opts.defaultRegion
+      expect(out.e164).toBe(intlIl)
+      expect(out.regionCode).toBe('IL')
+    })
 
-  it('normalizePhoneOrThrowWithRegion: accepts national number with region', () => {
-    const out = normalizePhoneOrThrowWithRegion('052-344-4444', 'IL')
-    expect(out.e164).toBe(intlIl)
-    expect(out.regionCode).toBe('IL')
-    expect(out.national).toMatch(/052/)
+    it('normalizePhoneOrThrowWithRegion: accepts national number with region', () => {
+      const out = normalizePhoneOrThrowWithRegion('052-344-4444', 'IL')
+      expect(out.e164).toBe(intlIl)
+      expect(out.regionCode).toBe('IL')
+      expect(out.national).toMatch(/052/)
+    })
   })
 })