@learncard/react 2.3.52 → 2.3.55

package/dist/cjs/{VCVerificationPill-656a2742.js → VCVerificationPill-202e3a97.js}

@@ -14,6 +14,9 @@ var VerificationWarningIcon__default = /*#__PURE__*/_interopDefaultLegacy(Verifi
 
 var util;
 (function (util) {
+    util.assertEqual = (val) => val;
+    function assertIs(_arg) { }
+    util.assertIs = assertIs;
     function assertNever(_x) {
         throw new Error();
     }
@@ -65,6 +68,12 @@ var util;
             .join(separator);
     }
     util.joinValues = joinValues;
+    util.jsonStringifyReplacer = (_, value) => {
+        if (typeof value === "bigint") {
+            return value.toString();
+        }
+        return value;
+    };
 })(util || (util = {}));
 const ZodParsedType = util.arrayToEnum([
     "string",
@@ -229,7 +238,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, null, 2);
+        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -256,7 +265,8 @@ ZodError.create = (issues) => {
     const error = new ZodError(issues);
     return error;
 };
-const defaultErrorMap = (issue, _ctx) => {
+
+const errorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case ZodIssueCode.invalid_type:
@@ -268,7 +278,7 @@ const defaultErrorMap = (issue, _ctx) => {
             }
             break;
         case ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
             break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
@@ -292,10 +302,23 @@ const defaultErrorMap = (issue, _ctx) => {
             message = `Invalid date`;
             break;
         case ZodIssueCode.invalid_string:
-            if (issue.validation !== "regex")
+            if (typeof issue.validation === "object") {
+                if ("startsWith" in issue.validation) {
+                    message = `Invalid input: must start with "${issue.validation.startsWith}"`;
+                }
+                else if ("endsWith" in issue.validation) {
+                    message = `Invalid input: must end with "${issue.validation.endsWith}"`;
+                }
+                else {
+                    util.assertNever(issue.validation);
+                }
+            }
+            else if (issue.validation !== "regex") {
                 message = `Invalid ${issue.validation}`;
-            else
+            }
+            else {
                 message = "Invalid";
+            }
             break;
         case ZodIssueCode.too_small:
             if (issue.type === "array")
@@ -304,6 +327,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be greater than ${issue.inclusive ? `or equal to ` : ``}${issue.minimum}`;
+            else if (issue.type === "date")
+                message = `Date must be greater than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.minimum)}`;
             else
                 message = "Invalid input";
             break;
@@ -314,6 +339,8 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `String must contain ${issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
             else if (issue.type === "number")
                 message = `Number must be less than ${issue.inclusive ? `or equal to ` : ``}${issue.maximum}`;
+            else if (issue.type === "date")
+                message = `Date must be smaller than ${issue.inclusive ? `or equal to ` : ``}${new Date(issue.maximum)}`;
             else
                 message = "Invalid input";
             break;
@@ -332,10 +359,14 @@ const defaultErrorMap = (issue, _ctx) => {
     }
     return { message };
 };
-let overrideErrorMap = defaultErrorMap;
-const setErrorMap = (map) => {
+
+let overrideErrorMap = errorMap;
+function setErrorMap(map) {
     overrideErrorMap = map;
-};
+}
+function getErrorMap() {
+    return overrideErrorMap;
+}
 
 const makeIssue = (params) => {
     const { data, path, errorMaps, issueData } = params;
@@ -367,8 +398,8 @@ function addIssueToContext(ctx, issueData) {
         errorMaps: [
             ctx.common.contextualErrorMap,
             ctx.schemaErrorMap,
-            overrideErrorMap,
-            defaultErrorMap,
+            getErrorMap(),
+            errorMap,
         ].filter((x) => !!x),
     });
     ctx.common.issues.push(issue);
@@ -469,18 +500,17 @@ function processCreateParams(params) {
         return {};
     const { errorMap, invalid_type_error, required_error, description } = params;
     if (errorMap && (invalid_type_error || required_error)) {
-        throw new Error(`Can't use "invalid" or "required" in conjunction with custom error map.`);
+        throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
     }
     if (errorMap)
         return { errorMap: errorMap, description };
     const customMap = (iss, ctx) => {
         if (iss.code !== "invalid_type")
             return { message: ctx.defaultError };
-        if (typeof ctx.data === "undefined" && required_error)
-            return { message: required_error };
-        if (params.invalid_type_error)
-            return { message: params.invalid_type_error };
-        return { message: ctx.defaultError };
+        if (typeof ctx.data === "undefined") {
+            return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+        }
+        return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
     };
     return { errorMap: customMap, description };
 }
@@ -693,6 +723,13 @@ class ZodType {
             typeName: ZodFirstPartyTypeKind.ZodDefault,
         });
     }
+    brand() {
+        return new ZodBranded({
+            typeName: ZodFirstPartyTypeKind.ZodBranded,
+            type: this,
+            ...processCreateParams(undefined),
+        });
+    }
     describe(description) {
         const This = this.constructor;
         return new This({
@@ -837,6 +874,28 @@ class ZodString extends ZodType {
             else if (check.kind === "trim") {
                 input.data = input.data.trim();
             }
+            else if (check.kind === "startsWith") {
+                if (!input.data.startsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.invalid_string,
+                        validation: { startsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "endsWith") {
+                if (!input.data.endsWith(check.value)) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.invalid_string,
+                        validation: { endsWith: check.value },
+                        message: check.message,
+                    });
+                    status.dirty();
+                }
+            }
             else {
                 util.assertNever(check);
             }
@@ -868,6 +927,20 @@ class ZodString extends ZodType {
             ...errorUtil.errToObj(message),
         });
     }
+    startsWith(value, message) {
+        return this._addCheck({
+            kind: "startsWith",
+            value: value,
+            ...errorUtil.errToObj(message),
+        });
+    }
+    endsWith(value, message) {
+        return this._addCheck({
+            kind: "endsWith",
+            value: value,
+            ...errorUtil.errToObj(message),
+        });
+    }
     min(minLength, message) {
         return this._addCheck({
             kind: "min",
@@ -898,25 +971,23 @@ class ZodString extends ZodType {
         return !!this._def.checks.find((ch) => ch.kind === "cuid");
     }
     get minLength() {
-        let min = -Infinity;
-        this._def.checks.map((ch) => {
+        let min = null;
+        for (const ch of this._def.checks) {
             if (ch.kind === "min") {
-                if (min === null || ch.value > min) {
+                if (min === null || ch.value > min)
                     min = ch.value;
-                }
             }
-        });
+        }
         return min;
     }
     get maxLength() {
         let max = null;
-        this._def.checks.map((ch) => {
+        for (const ch of this._def.checks) {
             if (ch.kind === "max") {
-                if (max === null || ch.value < max) {
+                if (max === null || ch.value < max)
                     max = ch.value;
-                }
             }
-        });
+        }
         return max;
     }
 }
@@ -1187,14 +1258,88 @@ class ZodDate extends ZodType {
             });
             return INVALID;
         }
+        const status = new ParseStatus();
+        let ctx = undefined;
+        for (const check of this._def.checks) {
+            if (check.kind === "min") {
+                if (input.data.getTime() < check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_small,
+                        message: check.message,
+                        inclusive: true,
+                        minimum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else if (check.kind === "max") {
+                if (input.data.getTime() > check.value) {
+                    ctx = this._getOrReturnCtx(input, ctx);
+                    addIssueToContext(ctx, {
+                        code: ZodIssueCode.too_big,
+                        message: check.message,
+                        inclusive: true,
+                        maximum: check.value,
+                        type: "date",
+                    });
+                    status.dirty();
+                }
+            }
+            else {
+                util.assertNever(check);
+            }
+        }
         return {
-            status: "valid",
+            status: status.value,
             value: new Date(input.data.getTime()),
         };
     }
+    _addCheck(check) {
+        return new ZodDate({
+            ...this._def,
+            checks: [...this._def.checks, check],
+        });
+    }
+    min(minDate, message) {
+        return this._addCheck({
+            kind: "min",
+            value: minDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    max(maxDate, message) {
+        return this._addCheck({
+            kind: "max",
+            value: maxDate.getTime(),
+            message: errorUtil.toString(message),
+        });
+    }
+    get minDate() {
+        let min = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "min") {
+                if (min === null || ch.value > min)
+                    min = ch.value;
+            }
+        }
+        return min != null ? new Date(min) : null;
+    }
+    get maxDate() {
+        let max = null;
+        for (const ch of this._def.checks) {
+            if (ch.kind === "max") {
+                if (max === null || ch.value < max)
+                    max = ch.value;
+            }
+        }
+        return max != null ? new Date(max) : null;
+    }
 }
 ZodDate.create = (params) => {
     return new ZodDate({
+        checks: [],
         typeName: ZodFirstPartyTypeKind.ZodDate,
         ...processCreateParams(params),
     });
@@ -1476,9 +1621,12 @@ class ZodObject extends ZodType {
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
         const extraKeys = [];
-        for (const key in ctx.data) {
-            if (!shapeKeys.includes(key)) {
-                extraKeys.push(key);
+        if (!(this._def.catchall instanceof ZodNever &&
+            this._def.unknownKeys === "strip")) {
+            for (const key in ctx.data) {
+                if (!shapeKeys.includes(key)) {
+                    extraKeys.push(key);
+                }
             }
         }
         const pairs = [];
@@ -1683,6 +1831,9 @@ class ZodObject extends ZodType {
             shape: () => newShape,
         });
     }
+    keyof() {
+        return createZodEnum(util.objectKeys(this.shape));
+    }
 }
 ZodObject.create = (shape, params) => {
     return new ZodObject({
@@ -2043,6 +2194,9 @@ class ZodTuple extends ZodType {
     }
 }
 ZodTuple.create = (schemas, params) => {
+    if (!Array.isArray(schemas)) {
+        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
+    }
     return new ZodTuple({
         items: schemas,
         typeName: ZodFirstPartyTypeKind.ZodTuple,
@@ -2270,8 +2424,8 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
-                    defaultErrorMap,
+                    getErrorMap(),
+                    errorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_arguments,
@@ -2286,8 +2440,8 @@ class ZodFunction extends ZodType {
                 errorMaps: [
                     ctx.common.contextualErrorMap,
                     ctx.schemaErrorMap,
-                    overrideErrorMap,
-                    defaultErrorMap,
+                    getErrorMap(),
+                    errorMap,
                 ].filter((x) => !!x),
                 issueData: {
                     code: ZodIssueCode.invalid_return_type,
@@ -2357,17 +2511,17 @@ class ZodFunction extends ZodType {
         const validatedFunc = this.parse(func);
         return validatedFunc;
     }
+    static create(args, returns, params) {
+        return new ZodFunction({
+            args: (args
+                ? args
+                : ZodTuple.create([]).rest(ZodUnknown.create())),
+            returns: returns || ZodUnknown.create(),
+            typeName: ZodFirstPartyTypeKind.ZodFunction,
+            ...processCreateParams(params),
+        });
+    }
 }
-ZodFunction.create = (args, returns, params) => {
-    return new ZodFunction({
-        args: (args
-            ? args.rest(ZodUnknown.create())
-            : ZodTuple.create([]).rest(ZodUnknown.create())),
-        returns: returns || ZodUnknown.create(),
-        typeName: ZodFirstPartyTypeKind.ZodFunction,
-        ...processCreateParams(params),
-    });
-};
 class ZodLazy extends ZodType {
     get schema() {
         return this._def.getter();
@@ -2748,6 +2902,21 @@ ZodNaN.create = (params) => {
         ...processCreateParams(params),
     });
 };
+const BRAND = Symbol("zod_brand");
+class ZodBranded extends ZodType {
+    _parse(input) {
+        const { ctx } = this._processInputParams(input);
+        const data = ctx.data;
+        return this._def.type._parse({
+            data,
+            path: ctx.path,
+            parent: ctx,
+        });
+    }
+    unwrap() {
+        return this._def.type;
+    }
+}
 const custom = (check, params = {}, fatal) => {
     if (check)
         return ZodAny.create().superRefine((data, ctx) => {
@@ -2795,7 +2964,14 @@ var ZodFirstPartyTypeKind;
     ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
     ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
     ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
+    ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
 })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
+// new approach that works for abstract classes
+// but required TS 4.4+
+// abstract class Class {
+//   constructor(..._: any[]) {}
+// }
+// const instanceOfType = <T extends typeof Class>(
 const instanceOfType = (cls, params = {
     message: `Input not instance of ${cls.name}`,
 }) => custom((data) => data instanceof cls, params, true);
@@ -2834,11 +3010,15 @@ const preprocessType = ZodEffects.createWithPreprocess;
 const ostring = () => stringType().optional();
 const onumber = () => numberType().optional();
 const oboolean = () => booleanType().optional();
+const NEVER = INVALID;
 
 var mod = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getParsedType: getParsedType,
     ZodParsedType: ZodParsedType,
+    defaultErrorMap: errorMap,
+    setErrorMap: setErrorMap,
+    getErrorMap: getErrorMap,
     makeIssue: makeIssue,
     EMPTY_PATH: EMPTY_PATH,
     addIssueToContext: addIssueToContext,
@@ -2884,6 +3064,8 @@ var mod = /*#__PURE__*/Object.freeze({
     ZodNullable: ZodNullable,
     ZodDefault: ZodDefault,
     ZodNaN: ZodNaN,
+    BRAND: BRAND,
+    ZodBranded: ZodBranded,
     custom: custom,
     Schema: ZodType,
     ZodSchema: ZodType,
@@ -2926,12 +3108,10 @@ var mod = /*#__PURE__*/Object.freeze({
     union: unionType,
     unknown: unknownType,
     'void': voidType,
+    NEVER: NEVER,
     ZodIssueCode: ZodIssueCode,
     quotelessJson: quotelessJson,
-    ZodError: ZodError,
-    defaultErrorMap: defaultErrorMap,
-    get overrideErrorMap () { return overrideErrorMap; },
-    setErrorMap: setErrorMap
+    ZodError: ZodError
 });
 
 var ContextValidator = mod.string().array();
@@ -2939,11 +3119,13 @@ mod.object({
   type: mod.string().optional(),
   narrative: mod.string().optional()
 });
-var ImageValidator = mod.string().or(mod.object({
-  id: mod.string(),
-  type: mod.string(),
-  caption: mod.string().optional()
-}));
+var ImageValidator = mod.string().or(
+  mod.object({
+    id: mod.string(),
+    type: mod.string(),
+    caption: mod.string().optional()
+  })
+);
 var GeoCoordinatesValidator = mod.object({
   type: mod.string().min(1).or(mod.string().array().nonempty()),
   latitude: mod.number(),
@@ -2985,29 +3167,31 @@ var IdentifierEntryValidator = mod.object({
   identifier: mod.string(),
   identifierType: IdentifierTypeValidator
 });
-var ProfileValidator = mod.string().or(mod.object({
-  id: mod.string().optional(),
-  type: mod.string().or(mod.string().array().nonempty().optional()),
-  name: mod.string().optional(),
-  url: mod.string().optional(),
-  phone: mod.string().optional(),
-  description: mod.string().optional(),
-  endorsement: mod.any().array().optional(),
-  image: ImageValidator.optional(),
-  email: mod.string().email().optional(),
-  address: AddressValidator.optional(),
-  otherIdentifier: IdentifierEntryValidator.array().optional(),
-  official: mod.string().optional(),
-  parentOrg: mod.any().optional(),
-  familyName: mod.string().optional(),
-  givenName: mod.string().optional(),
-  additionalName: mod.string().optional(),
-  patronymicName: mod.string().optional(),
-  honorificPrefix: mod.string().optional(),
-  honorificSuffix: mod.string().optional(),
-  familyNamePrefix: mod.string().optional(),
-  dateOfBirth: mod.string().optional()
-}).catchall(mod.any()));
+var ProfileValidator = mod.string().or(
+  mod.object({
+    id: mod.string().optional(),
+    type: mod.string().or(mod.string().array().nonempty().optional()),
+    name: mod.string().optional(),
+    url: mod.string().optional(),
+    phone: mod.string().optional(),
+    description: mod.string().optional(),
+    endorsement: mod.any().array().optional(),
+    image: ImageValidator.optional(),
+    email: mod.string().email().optional(),
+    address: AddressValidator.optional(),
+    otherIdentifier: IdentifierEntryValidator.array().optional(),
+    official: mod.string().optional(),
+    parentOrg: mod.any().optional(),
+    familyName: mod.string().optional(),
+    givenName: mod.string().optional(),
+    additionalName: mod.string().optional(),
+    patronymicName: mod.string().optional(),
+    honorificPrefix: mod.string().optional(),
+    honorificSuffix: mod.string().optional(),
+    familyNamePrefix: mod.string().optional(),
+    dateOfBirth: mod.string().optional()
+  }).catchall(mod.any())
+);
 var CredentialSubjectValidator = mod.object({ id: mod.string().optional() }).catchall(mod.any());
 var CredentialStatusValidator = mod.object({ type: mod.string(), id: mod.string() });
 var CredentialSchemaValidator = mod.object({ id: mod.string(), type: mod.string() });
@@ -3041,7 +3225,7 @@ var UnsignedVPValidator = mod.object({
   "@context": ContextValidator,
   id: mod.string().optional(),
   type: mod.string().array().nonempty(),
-  verifiableCredential: VCValidator.or(VCValidator.array()),
+  verifiableCredential: VCValidator.or(VCValidator.array()).optional(),
   holder: mod.string().optional()
 }).catchall(mod.any());
 UnsignedVPValidator.extend({
@@ -3319,4 +3503,4 @@ const VCVerificationPill = ({
 
 exports.VCVerificationPill = VCVerificationPill;
 exports.ValidationStateIndicator = ValidationStateIndicator;
-//# sourceMappingURL=VCVerificationPill-656a2742.js.map
+//# sourceMappingURL=VCVerificationPill-202e3a97.js.map