us-ssn-tools 1.0.0 → 2.0.0

package/dist/normalize.d.ts

@@ -1,15 +1,33 @@
 export interface NormalizeSsnOptions {
-    allowNoDashes?: boolean;
+    /**
+     * If true, formats prefixes while typing.
+     * - dashed mode: "1234" -> "123-4"
+     * - digits-only mode: returns digits as-is
+     *
+     * Default: true
+     */
     allowPartial?: boolean;
+    /**
+     * If true, return digits only (no dashes inserted).
+     * If false, insert dashes in ###-##-#### style.
+     *
+     * Default: false
+     */
+    digitsOnly?: boolean;
+    /**
+     * If true, cap extracted digits at 9.
+     * If false, allow any number of digits (useful for UI behavior testing).
+     *
+     * Default: true
+     */
+    enforceLength?: boolean;
 }
-export type NormalizeSsnOk = {
-    ok: true;
-    digits: string;
-    normalized: string;
-};
-export type NormalizeSsnErr = {
-    ok: false;
-    message: string;
-};
-export type NormalizeSsnResult = NormalizeSsnOk | NormalizeSsnErr;
-export declare function normalizeSsnInput(input: string, opts?: NormalizeSsnOptions): NormalizeSsnResult;
+/**
+ * Best-effort SSN normalization for UI display.
+ * - Returns a string only (no validity info).
+ * - Never throws.
+ * - Extracts digits from input and optionally inserts dashes.
+ * - Optionally caps to 9 digits (enforceLength).
+ * - Keeps behavior predictable for "typing-as-you-go".
+ */
+export declare function normalizeSsn(input: string, opts?: NormalizeSsnOptions): string;

package/dist/normalize.js

@@ -1,62 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeSsnInput = normalizeSsnInput;
+exports.normalizeSsn = normalizeSsn;
 const utils_1 = require("./utils");
-function normalizeSsnInput(input, opts = {}) {
-    var _a, _b;
-    const allowNoDashes = (_a = opts.allowNoDashes) !== null && _a !== void 0 ? _a : true;
-    const allowPartial = (_b = opts.allowPartial) !== null && _b !== void 0 ? _b : false;
-    const raw = input;
-    // Full (non-partial) normalization
-    if (!allowPartial) {
-        if (/^\d{3}-\d{2}-\d{4}$/.test(raw)) {
-            return {
-                ok: true,
-                digits: raw.replace(/-/g, ''),
-                normalized: raw,
-            };
-        }
-        if (allowNoDashes && /^\d{9}$/.test(raw)) {
-            return {
-                ok: true,
-                digits: raw,
-                normalized: `${raw.slice(0, 3)}-${raw.slice(3, 5)}-${raw.slice(5)}`,
-            };
-        }
-        return { ok: false, message: 'Invalid SSN format.' };
-    }
-    // ---- Partial / typing-as-you-go normalization ----
-    if (!/^[0-9-]*$/.test(raw)) {
-        return { ok: false, message: "Only digits and '-' are allowed." };
-    }
+/**
+ * Best-effort SSN normalization for UI display.
+ * - Returns a string only (no validity info).
+ * - Never throws.
+ * - Extracts digits from input and optionally inserts dashes.
+ * - Optionally caps to 9 digits (enforceLength).
+ * - Keeps behavior predictable for "typing-as-you-go".
+ */
+function normalizeSsn(input, opts = {}) {
+    var _a, _b, _c;
+    const allowPartial = (_a = opts.allowPartial) !== null && _a !== void 0 ? _a : true;
+    const digitsOnly = (_b = opts.digitsOnly) !== null && _b !== void 0 ? _b : false;
+    const enforceLength = (_c = opts.enforceLength) !== null && _c !== void 0 ? _c : true;
+    // Extract digits, optionally cap to 9 for SSN-shaped output.
     let digits = '';
-    let sawDashAt3 = false;
-    let sawDashAt5 = false;
-    for (const ch of raw) {
+    for (const ch of input) {
         if (ch >= '0' && ch <= '9') {
             digits += ch;
-            if (digits.length > 9) {
-                return { ok: false, message: 'SSN is too long.' };
-            }
-            continue;
-        }
-        // ch === '-'
-        if (!allowNoDashes) {
-            return { ok: false, message: 'Dashes are not allowed.' };
-        }
-        if (digits.length === 3 && !sawDashAt3) {
-            sawDashAt3 = true;
-        }
-        else if (digits.length === 5 && !sawDashAt5) {
-            sawDashAt5 = true;
-        }
-        else {
-            return { ok: false, message: 'Dash is in an invalid position.' };
+            if (enforceLength && digits.length === 9)
+                break;
         }
     }
-    return {
-        ok: true,
-        digits,
-        normalized: (0, utils_1.formatSsnFromDigits)(digits),
-    };
+    if (digitsOnly) {
+        // digits-only output: just return the extracted digits (possibly >9 if enforceLength=false)
+        return digits;
+    }
+    // dashed output
+    if (allowPartial) {
+        // Typing mode: format prefix. If digits > 9 and enforceLength=false,
+        // we format the SSN-shaped prefix and append the rest after the serial.
+        return (0, utils_1.formatSsnWithOverflow)(digits);
+    }
+    // Non-partial mode: only format if we have a full 9 digits; otherwise return input unchanged.
+    // (Prevents jumpy formatting in contexts where you don't want as-you-type behavior.)
+    if (digits.length === 9 || (enforceLength && digits.length === 9)) {
+        return (0, utils_1.formatSsnFromDigits)(digits.slice(0, 9));
+    }
+    return input;
 }

package/dist/utils.d.ts

@@ -1,4 +1,9 @@
 /**
- * Format SSN from digits. Used for UI formatting.
+ * Format SSN from digits. Used for UI
  */
 export declare function formatSsnFromDigits(digits: string): string;
+/**
+ * Formats digits as ###-##-#### and if there are extra digits, appends them after the serial.
+ * Example: "12345678999" -> "123-45-678999"
+ */
+export declare function formatSsnWithOverflow(digits: string): string;

package/dist/utils.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatSsnFromDigits = formatSsnFromDigits;
+exports.formatSsnWithOverflow = formatSsnWithOverflow;
 /**
- * Format SSN from digits. Used for UI formatting.
+ * Format SSN from digits. Used for UI
  */
 function formatSsnFromDigits(digits) {
     if (digits.length <= 3)
@@ -11,3 +12,12 @@ function formatSsnFromDigits(digits) {
         return `${digits.slice(0, 3)}-${digits.slice(3)}`;
     return `${digits.slice(0, 3)}-${digits.slice(3, 5)}-${digits.slice(5)}`;
 }
+/**
+ * Formats digits as ###-##-#### and if there are extra digits, appends them after the serial.
+ * Example: "12345678999" -> "123-45-678999"
+ */
+function formatSsnWithOverflow(digits) {
+    if (digits.length <= 9)
+        return formatSsnFromDigits(digits);
+    return `${formatSsnFromDigits(digits.slice(0, 9))}${digits.slice(9)}`;
+}

package/dist/validate.d.ts

@@ -1,43 +1,25 @@
-export type SsnValidationFailureReason = 'INVALID_FORMAT' | 'INVALID_AREA' | 'INVALID_GROUP' | 'INVALID_SERIAL' | 'PUBLICLY_ADVERTISED';
-export type SsnRuleMode = 'pre2011' | 'post2011' | 'both';
-export type SsnValidationOkResult = {
-    ok: true;
-    normalized: string;
-};
-export type SsnValidationErrorResult = {
-    ok: false;
-    error: SsnValidationFailureReason;
-    message: string;
-};
-export type SsnValidationResult = SsnValidationOkResult | SsnValidationErrorResult;
+export type SsnRuleMode = 'pre2011' | 'post2011';
 export interface ValidateSsnOptions {
     /**
-     * If true, accept either "#########" or "###-##-####" as input.
-     * If false, require exact "###-##-####" (or partial prefix of it if allowPartial=true).
+     * If true, input must be in ###-##-#### (or a valid prefix of it when allowPartial=true).
+     * If false, accepts either ###-##-#### or ######### (and prefixes).
+     *
+     * Default: true
      */
-    allowNoDashes?: boolean;
+    requireDashes?: boolean;
     /**
-     * Which rule-set(s) to accept.
-     * - "pre2011": apply stricter pre–Jun 25 2011 area rules (734–749, >=773 invalid)
-     * - "post2011": do NOT apply those extra area restrictions
-     * - "both": accept either (default)
+     * Pre-2011 is stricter on area numbers (734-749 and >= 773 are invalid).
+     * Post-2011 uses only the base area rules (000, 666, 900-999 invalid).
      *
-     * Note: base rules (area 000/666/900-999, group 00, serial 0000, public list) still apply.
+     * Default: "post2011"
      */
     ruleMode?: SsnRuleMode;
     /**
-     * If true, allow "checking-as-you-go":
-     * - partial prefixes are accepted as long as they could still become valid
-     * - returned normalized string is the sanitized, dash-normalized prefix
+     * If true, accept prefixes that are still potentially valid as the user types.
+     * If false, require a complete SSN.
+     *
+     * Default: false
      */
     allowPartial?: boolean;
 }
-/**
- * Validates a US SSN with support for:
- * - strict full validation
- * - optional acceptance of no-dash input
- * - rule modes: pre2011 | post2011 | both (default)
- * - optional "checking-as-you-go" partial validation
- */ export declare function validateSsn(input: string, opts?: ValidateSsnOptions): SsnValidationResult;
-/** Convenience boolean wrapper */
 export declare function isValidSsn(input: string, opts?: ValidateSsnOptions): boolean;

package/dist/validate.js

@@ -1,179 +1,144 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateSsn = validateSsn;
 exports.isValidSsn = isValidSsn;
-const normalize_1 = require("./normalize");
 const PUBLICLY_ADVERTISED = new Set([
     '078-05-1120',
     '721-07-4426',
     '219-09-9999',
 ]);
-/**
- * Validates a US SSN with support for:
- * - strict full validation
- * - optional acceptance of no-dash input
- * - rule modes: pre2011 | post2011 | both (default)
- * - optional "checking-as-you-go" partial validation
- */ function validateSsn(input, opts = {}) {
+function isValidSsn(input, opts = {}) {
     var _a, _b, _c;
-    const allowNoDashes = (_a = opts.allowNoDashes) !== null && _a !== void 0 ? _a : true;
-    const ruleMode = (_b = opts.ruleMode) !== null && _b !== void 0 ? _b : 'both';
+    const requireDashes = (_a = opts.requireDashes) !== null && _a !== void 0 ? _a : true;
+    const ruleMode = (_b = opts.ruleMode) !== null && _b !== void 0 ? _b : 'post2011';
     const allowPartial = (_c = opts.allowPartial) !== null && _c !== void 0 ? _c : false;
-    const normalized = (0, normalize_1.normalizeSsnInput)(input, {
-        allowNoDashes,
-        allowPartial,
-    });
-    if (!normalized.ok) {
-        return {
-            ok: false,
-            error: 'INVALID_FORMAT',
-            message: normalized.message,
-        };
+    // 1) Format/prefix checks + digit extraction
+    const parsed = parseSsnInput(input, { requireDashes, allowPartial });
+    if (!parsed.ok)
+        return false;
+    const digits = parsed.digits;
+    // In strict (non-partial) mode, require exactly 9 digits.
+    if (!allowPartial && digits.length !== 9)
+        return false;
+    // 2) Rule checks (apply progressively in partial mode)
+    // Area (first 3)
+    if (digits.length >= 3) {
+        const area = Number(digits.slice(0, 3));
+        if (!isValidArea(area, ruleMode))
+            return false;
     }
-    const digits = normalized.digits;
-    const area = digits.slice(0, 3);
-    const group = digits.slice(3, 5);
-    const serial = digits.slice(5, 9);
-    if (!allowPartial && PUBLICLY_ADVERTISED.has(normalized.normalized)) {
-        return {
-            ok: false,
-            error: 'PUBLICLY_ADVERTISED',
-            message: 'This SSN is a known publicly advertised (and invalid) value.',
-        };
+    // Group (next 2)
+    if (digits.length >= 5) {
+        const group = Number(digits.slice(3, 5));
+        if (group === 0)
+            return false; // "00"
     }
-    const ruleCheck = allowPartial
-        ? validatePartialSegments(area, group, serial, ruleMode)
-        : validateFullSegments(area, group, serial, ruleMode);
-    if (!ruleCheck.ok)
-        return ruleCheck;
-    return { ok: true, normalized: normalized.normalized };
-}
-/** Convenience boolean wrapper */
-function isValidSsn(input, opts) {
-    return validateSsn(input, opts).ok;
-}
-function normalizePrefix(digits) {
-    // digits: 0..9 chars
-    if (digits.length <= 3)
-        return digits;
-    if (digits.length <= 5)
-        return `${digits.slice(0, 3)}-${digits.slice(3)}`;
-    return `${digits.slice(0, 3)}-${digits.slice(3, 5)}-${digits.slice(5)}`;
-}
-/* -------------------------- Rules -------------------------- */
-function validateFullSegments(area, group, serial, ruleMode) {
-    const areaNum = Number(area);
-    const groupNum = Number(group);
-    const serialNum = Number(serial);
-    // Base Rule 2: area cannot be 000, 666, or 900–999
-    if (areaNum === 0 || areaNum === 666 || areaNum >= 900) {
-        return {
-            ok: false,
-            error: 'INVALID_AREA',
-            message: 'Area number is not allowed (000, 666, and 900–999 are invalid).',
-        };
-    }
-    // Ruleset selection:
-    // - pre2011: apply extra reserved ranges
-    // - post2011: do not
-    // - both: accept if EITHER passes (so we only fail if it violates post rules AND pre rules)
-    const violatesPre2011 = (areaNum >= 734 && areaNum <= 749) || areaNum >= 773;
-    if (ruleMode === 'pre2011' && violatesPre2011) {
-        return {
-            ok: false,
-            error: 'INVALID_AREA',
-            message: 'Area number is not allowed under pre–June 25, 2011 rules (734–749 and >= 773 are invalid).',
-        };
-    }
-    if (ruleMode === 'both') {
-        // If it violates pre2011, it's still acceptable as post2011.
-        // So no action needed.
+    // Serial (last 4)
+    if (digits.length === 9) {
+        const serial = Number(digits.slice(5, 9));
+        if (serial === 0)
+            return false; // "0000"
+        // Publicly advertised SSNs are always invalid
+        const dashed = `${digits.slice(0, 3)}-${digits.slice(3, 5)}-${digits.slice(5)}`;
+        if (PUBLICLY_ADVERTISED.has(dashed))
+            return false;
     }
-    // Rule 3: group cannot be 00
-    if (groupNum === 0) {
-        return {
-            ok: false,
-            error: 'INVALID_GROUP',
-            message: 'Group number may not be 00.',
-        };
-    }
-    // Rule 4: serial cannot be 0000
-    if (serialNum === 0) {
-        return {
-            ok: false,
-            error: 'INVALID_SERIAL',
-            message: 'Serial number may not be 0000.',
-        };
-    }
-    // Rule 7: publicly advertised checked in validateSsn (full only)
-    return { ok: true, normalized: `${area}-${group}-${serial}` };
+    // If partial, any prefix that passed the progressive checks is considered valid so far.
+    return true;
 }
-function validatePartialSegments(area, group, serial, ruleMode) {
-    // AREA checks while typing:
-    // - if first digit is '9', area can never be valid (since 900–999 invalid)
-    if (area.length >= 1 && area[0] === '9') {
-        return {
-            ok: false,
-            error: 'INVALID_AREA',
-            message: 'Area numbers starting with 9 are not allowed.',
-        };
+/* ---------------- helpers ---------------- */
+function isValidArea(area, ruleMode) {
+    // Base rules (always)
+    if (area === 0)
+        return false; // 000
+    if (area === 666)
+        return false;
+    if (area >= 900)
+        return false;
+    // Pre-2011 additional rules
+    if (ruleMode === 'pre2011') {
+        if (area >= 734 && area <= 749)
+            return false;
+        if (area >= 773)
+            return false;
     }
-    // - if area is complete (3 digits), enforce base rule 2 and (optionally) pre2011 when in pre-only mode
-    if (area.length === 3) {
-        const areaNum = Number(area);
-        if (areaNum === 0 || areaNum === 666 || areaNum >= 900) {
-            return {
-                ok: false,
-                error: 'INVALID_AREA',
-                message: 'Area number is not allowed (000, 666, and 900–999 are invalid).',
-            };
+    return true;
+}
+function parseSsnInput(input, opts) {
+    const { requireDashes, allowPartial } = opts;
+    if (!allowPartial) {
+        // Full input only
+        if (/^\d{3}-\d{2}-\d{4}$/.test(input)) {
+            return { ok: true, digits: input.replace(/-/g, '') };
         }
-        const violatesPre2011 = (areaNum >= 734 && areaNum <= 749) || areaNum >= 773;
-        if (ruleMode === 'pre2011' && violatesPre2011) {
-            return {
-                ok: false,
-                error: 'INVALID_AREA',
-                message: 'Area number is not allowed under pre–June 25, 2011 rules (734–749 and >= 773 are invalid).',
-            };
+        if (!requireDashes && /^\d{9}$/.test(input)) {
+            return { ok: true, digits: input };
         }
-        // ruleMode "both" accepts either; "post2011" ignores extra restrictions.
+        return { ok: false };
     }
-    // GROUP checks while typing:
-    // Only enforce once group is complete (2 digits)
-    if (group.length === 2) {
-        const groupNum = Number(group);
-        if (groupNum === 0) {
-            return {
-                ok: false,
-                error: 'INVALID_GROUP',
-                message: 'Group number may not be 00.',
-            };
+    // Partial / typing-as-you-go
+    if (requireDashes) {
+        // Must be a prefix of ###-##-####
+        // Allowed prefixes include:
+        // "", "1", "12", "123", "123-", "123-4", "123-45", "123-45-", "123-45-6", ...
+        if (!/^[0-9-]*$/.test(input))
+            return { ok: false };
+        // Enforce dash positions and ordering as user types.
+        // Build digits while ensuring '-' only appears right after 3 and 5 digits (and at most once each).
+        let digits = '';
+        let sawDashAt3 = false;
+        let sawDashAt5 = false;
+        for (const ch of input) {
+            if (ch >= '0' && ch <= '9') {
+                if (digits.length >= 9)
+                    return { ok: false };
+                digits += ch;
+                continue;
+            }
+            // ch === '-'
+            if (digits.length === 3 && !sawDashAt3) {
+                sawDashAt3 = true;
+            }
+            else if (digits.length === 5 && !sawDashAt5) {
+                sawDashAt5 = true;
+            }
+            else {
+                return { ok: false };
+            }
         }
+        // Also disallow typing digits past 3 without having placed the first dash (since requireDashes=true).
+        // The loop above already enforces this implicitly: "1234" contains no dash; it's allowed as digits,
+        // but would be a prefix of digits-only, not of dashed format. If you want "1234" to be invalid
+        // when requireDashes=true, enforce it here:
+        if (digits.length > 3 && !sawDashAt3)
+            return { ok: false };
+        if (digits.length > 5 && !sawDashAt5)
+            return { ok: false };
+        return { ok: true, digits };
     }
-    // SERIAL checks while typing:
-    // Only enforce once serial is complete (4 digits)
-    if (serial.length === 4) {
-        const serialNum = Number(serial);
-        if (serialNum === 0) {
-            return {
-                ok: false,
-                error: 'INVALID_SERIAL',
-                message: 'Serial number may not be 0000.',
-            };
+    // requireDashes === false in partial mode:
+    // accept either digits-only prefixes or dashed prefixes (as long as dashes are in valid positions)
+    if (!/^[0-9-]*$/.test(input))
+        return { ok: false };
+    let digits = '';
+    let sawDashAt3 = false;
+    let sawDashAt5 = false;
+    for (const ch of input) {
+        if (ch >= '0' && ch <= '9') {
+            if (digits.length >= 9)
+                return { ok: false };
+            digits += ch;
+            continue;
+        }
+        // '-' present: enforce positions (same as dashed typing), but do not require them.
+        if (digits.length === 3 && !sawDashAt3) {
+            sawDashAt3 = true;
+        }
+        else if (digits.length === 5 && !sawDashAt5) {
+            sawDashAt5 = true;
         }
-        // Now that we have a full SSN in partial mode, also block publicly advertised.
-        const fullNormalized = `${area}-${group}-${serial}`;
-        if (PUBLICLY_ADVERTISED.has(fullNormalized)) {
-            return {
-                ok: false,
-                error: 'PUBLICLY_ADVERTISED',
-                message: 'This SSN is a known publicly advertised (and invalid) value.',
-            };
+        else {
+            return { ok: false };
         }
     }
-    // If we haven't hit a definitive violation yet, it's valid "so far".
-    return {
-        ok: true,
-        normalized: normalizePrefix((area + group + serial).slice(0, 9)),
-    };
+    return { ok: true, digits };
 }

package/dist/yup.d.ts

@@ -1,9 +1,14 @@
 import * as yup from 'yup';
 import { type ValidateSsnOptions } from './validate';
 /**
- * Yup schema for "typing": normalizes to a prefix and allows partial validity.
- * Note: transform runs before test in Yup.
+ * Yup schema for "typing":
+ * - transforms the input to a normalized prefix (UI-friendly)
+ * - validates "valid so far" (allowPartial=true)
  */
 export declare function yupSsnTyping(opts?: Omit<ValidateSsnOptions, 'allowPartial'>): yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;
-/** Yup schema for full submit */
+/**
+ * Yup schema for full submit:
+ * - transforms into a canonical SSN representation
+ * - validates strictly (allowPartial=false)
+ */
 export declare function yupSsnSubmit(opts?: Omit<ValidateSsnOptions, 'allowPartial'>): yup.StringSchema<string | undefined, yup.AnyObject, undefined, "">;

package/dist/yup.js

@@ -36,45 +36,56 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.yupSsnTyping = yupSsnTyping;
 exports.yupSsnSubmit = yupSsnSubmit;
 const yup = __importStar(require("yup"));
+const normalize_1 = require("./normalize");
 const validate_1 = require("./validate");
 /**
- * Yup schema for "typing": normalizes to a prefix and allows partial validity.
- * Note: transform runs before test in Yup.
+ * Yup schema for "typing":
+ * - transforms the input to a normalized prefix (UI-friendly)
+ * - validates "valid so far" (allowPartial=true)
  */
 function yupSsnTyping(opts = {}) {
     return yup
         .string()
         .transform((value) => {
         const v = (value !== null && value !== void 0 ? value : '').toString();
-        const res = (0, validate_1.validateSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: true }));
-        return res.ok ? res.normalized : v; // keep original if invalid; test will fail
+        // Normalize for UI: prefix formatting as the user types.
+        // Keep dashed output (digitsOnly=false) by default.
+        return (0, normalize_1.normalizeSsn)(v, {
+            allowPartial: true,
+            digitsOnly: false,
+            enforceLength: false,
+        });
     })
         .test('ssn-typing-valid', 'Invalid SSN', function (value) {
         const v = (value !== null && value !== void 0 ? value : '').toString();
-        const res = (0, validate_1.validateSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: true }));
-        return res.ok
-            ? true
-            : this.createError({
-                message: res.message,
-            });
+        const ok = (0, validate_1.isValidSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: true }));
+        return ok ? true : this.createError({ message: 'Invalid SSN' });
     });
 }
-/** Yup schema for full submit */
+/**
+ * Yup schema for full submit:
+ * - transforms into a canonical SSN representation
+ * - validates strictly (allowPartial=false)
+ */
 function yupSsnSubmit(opts = {}) {
     return yup
         .string()
         .transform((value) => {
+        var _a;
         const v = (value !== null && value !== void 0 ? value : '').toString();
-        const res = (0, validate_1.validateSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: false }));
-        return res.ok ? res.normalized : v;
+        // For submit, normalize to canonical form.
+        // If requireDashes is true (default), return dashed.
+        // If requireDashes is false, you might prefer digitsOnly, but we keep dashed for consistency.
+        const digitsOnly = ((_a = opts.requireDashes) !== null && _a !== void 0 ? _a : true) ? false : true;
+        return (0, normalize_1.normalizeSsn)(v, {
+            allowPartial: false,
+            digitsOnly,
+            enforceLength: true, // for submit, capping to 9 is usually desired
+        });
     })
         .test('ssn-submit-valid', 'Invalid SSN', function (value) {
         const v = (value !== null && value !== void 0 ? value : '').toString();
-        const res = (0, validate_1.validateSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: false }));
-        return res.ok
-            ? true
-            : this.createError({
-                message: res.message,
-            });
+        const ok = (0, validate_1.isValidSsn)(v, Object.assign(Object.assign({}, opts), { allowPartial: false }));
+        return ok ? true : this.createError({ message: 'Invalid SSN' });
     });
 }