@learncard/helpers 1.3.13 → 1.4.1

package/dist/helpers.esm.js

@@ -15079,7 +15079,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     var ZodFirstPartyTypeKind;
     /* @__PURE__ */ (function(ZodFirstPartyTypeKind2) {
     })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
-    var z2 = {
+    var z3 = {
       ...schemas_exports2,
       ...checks_exports2,
       iso: iso_exports
@@ -15193,7 +15193,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     function convertBaseSchema(schema, ctx) {
       if (schema.not !== void 0) {
         if (typeof schema.not === "object" && Object.keys(schema.not).length === 0) {
-          return z2.never();
+          return z3.never();
         }
         throw new Error("not is not supported in Zod (except { not: {} } for never)");
       }
@@ -15215,7 +15215,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           return ctx.refs.get(refPath);
         }
         if (ctx.processing.has(refPath)) {
-          return z2.lazy(() => {
+          return z3.lazy(() => {
             if (!ctx.refs.has(refPath)) {
               throw new Error(`Circular reference not resolved: ${refPath}`);
             }
@@ -15232,25 +15232,25 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       if (schema.enum !== void 0) {
         const enumValues = schema.enum;
         if (ctx.version === "openapi-3.0" && schema.nullable === true && enumValues.length === 1 && enumValues[0] === null) {
-          return z2.null();
+          return z3.null();
         }
         if (enumValues.length === 0) {
-          return z2.never();
+          return z3.never();
         }
         if (enumValues.length === 1) {
-          return z2.literal(enumValues[0]);
+          return z3.literal(enumValues[0]);
         }
         if (enumValues.every((v) => typeof v === "string")) {
-          return z2.enum(enumValues);
+          return z3.enum(enumValues);
         }
-        const literalSchemas = enumValues.map((v) => z2.literal(v));
+        const literalSchemas = enumValues.map((v) => z3.literal(v));
         if (literalSchemas.length < 2) {
           return literalSchemas[0];
         }
-        return z2.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
+        return z3.union([literalSchemas[0], literalSchemas[1], ...literalSchemas.slice(2)]);
       }
       if (schema.const !== void 0) {
-        return z2.literal(schema.const);
+        return z3.literal(schema.const);
       }
       const type = schema.type;
       if (Array.isArray(type)) {
@@ -15259,68 +15259,68 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           return convertBaseSchema(typeSchema, ctx);
         });
         if (typeSchemas.length === 0) {
-          return z2.never();
+          return z3.never();
         }
         if (typeSchemas.length === 1) {
           return typeSchemas[0];
         }
-        return z2.union(typeSchemas);
+        return z3.union(typeSchemas);
       }
       if (!type) {
-        return z2.any();
+        return z3.any();
       }
       let zodSchema;
       switch (type) {
         case "string": {
-          let stringSchema = z2.string();
+          let stringSchema = z3.string();
           if (schema.format) {
             const format = schema.format;
             if (format === "email") {
-              stringSchema = stringSchema.check(z2.email());
+              stringSchema = stringSchema.check(z3.email());
             } else if (format === "uri" || format === "uri-reference") {
-              stringSchema = stringSchema.check(z2.url());
+              stringSchema = stringSchema.check(z3.url());
             } else if (format === "uuid" || format === "guid") {
-              stringSchema = stringSchema.check(z2.uuid());
+              stringSchema = stringSchema.check(z3.uuid());
             } else if (format === "date-time") {
-              stringSchema = stringSchema.check(z2.iso.datetime());
+              stringSchema = stringSchema.check(z3.iso.datetime());
             } else if (format === "date") {
-              stringSchema = stringSchema.check(z2.iso.date());
+              stringSchema = stringSchema.check(z3.iso.date());
             } else if (format === "time") {
-              stringSchema = stringSchema.check(z2.iso.time());
+              stringSchema = stringSchema.check(z3.iso.time());
             } else if (format === "duration") {
-              stringSchema = stringSchema.check(z2.iso.duration());
+              stringSchema = stringSchema.check(z3.iso.duration());
             } else if (format === "ipv4") {
-              stringSchema = stringSchema.check(z2.ipv4());
+              stringSchema = stringSchema.check(z3.ipv4());
             } else if (format === "ipv6") {
-              stringSchema = stringSchema.check(z2.ipv6());
+              stringSchema = stringSchema.check(z3.ipv6());
             } else if (format === "mac") {
-              stringSchema = stringSchema.check(z2.mac());
+              stringSchema = stringSchema.check(z3.mac());
             } else if (format === "cidr") {
-              stringSchema = stringSchema.check(z2.cidrv4());
+              stringSchema = stringSchema.check(z3.cidrv4());
             } else if (format === "cidr-v6") {
-              stringSchema = stringSchema.check(z2.cidrv6());
+              stringSchema = stringSchema.check(z3.cidrv6());
             } else if (format === "base64") {
-              stringSchema = stringSchema.check(z2.base64());
+              stringSchema = stringSchema.check(z3.base64());
             } else if (format === "base64url") {
-              stringSchema = stringSchema.check(z2.base64url());
+              stringSchema = stringSchema.check(z3.base64url());
             } else if (format === "e164") {
-              stringSchema = stringSchema.check(z2.e164());
+              stringSchema = stringSchema.check(z3.e164());
             } else if (format === "jwt") {
-              stringSchema = stringSchema.check(z2.jwt());
+              stringSchema = stringSchema.check(z3.jwt());
             } else if (format === "emoji") {
-              stringSchema = stringSchema.check(z2.emoji());
+              stringSchema = stringSchema.check(z3.emoji());
             } else if (format === "nanoid") {
-              stringSchema = stringSchema.check(z2.nanoid());
+              stringSchema = stringSchema.check(z3.nanoid());
             } else if (format === "cuid") {
-              stringSchema = stringSchema.check(z2.cuid());
+              stringSchema = stringSchema.check(z3.cuid());
             } else if (format === "cuid2") {
-              stringSchema = stringSchema.check(z2.cuid2());
+              stringSchema = stringSchema.check(z3.cuid2());
             } else if (format === "ulid") {
-              stringSchema = stringSchema.check(z2.ulid());
+              stringSchema = stringSchema.check(z3.ulid());
             } else if (format === "xid") {
-              stringSchema = stringSchema.check(z2.xid());
+              stringSchema = stringSchema.check(z3.xid());
             } else if (format === "ksuid") {
-              stringSchema = stringSchema.check(z2.ksuid());
+              stringSchema = stringSchema.check(z3.ksuid());
             }
           }
           if (typeof schema.minLength === "number") {
@@ -15337,7 +15337,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
         }
         case "number":
         case "integer": {
-          let numberSchema = type === "integer" ? z2.number().int() : z2.number();
+          let numberSchema = type === "integer" ? z3.number().int() : z3.number();
           if (typeof schema.minimum === "number") {
             numberSchema = numberSchema.min(schema.minimum);
           }
@@ -15361,11 +15361,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           break;
         }
         case "boolean": {
-          zodSchema = z2.boolean();
+          zodSchema = z3.boolean();
           break;
         }
         case "null": {
-          zodSchema = z2.null();
+          zodSchema = z3.null();
           break;
         }
         case "object": {
@@ -15378,14 +15378,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
           }
           if (schema.propertyNames) {
             const keySchema = convertSchema(schema.propertyNames, ctx);
-            const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z2.any();
+            const valueSchema = schema.additionalProperties && typeof schema.additionalProperties === "object" ? convertSchema(schema.additionalProperties, ctx) : z3.any();
             if (Object.keys(shape).length === 0) {
-              zodSchema = z2.record(keySchema, valueSchema);
+              zodSchema = z3.record(keySchema, valueSchema);
               break;
             }
-            const objectSchema2 = z2.object(shape).passthrough();
-            const recordSchema = z2.looseRecord(keySchema, valueSchema);
-            zodSchema = z2.intersection(objectSchema2, recordSchema);
+            const objectSchema2 = z3.object(shape).passthrough();
+            const recordSchema = z3.looseRecord(keySchema, valueSchema);
+            zodSchema = z3.intersection(objectSchema2, recordSchema);
             break;
           }
           if (schema.patternProperties) {
@@ -15394,28 +15394,28 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             const looseRecords = [];
             for (const pattern of patternKeys) {
               const patternValue = convertSchema(patternProps[pattern], ctx);
-              const keySchema = z2.string().regex(new RegExp(pattern));
-              looseRecords.push(z2.looseRecord(keySchema, patternValue));
+              const keySchema = z3.string().regex(new RegExp(pattern));
+              looseRecords.push(z3.looseRecord(keySchema, patternValue));
             }
             const schemasToIntersect = [];
             if (Object.keys(shape).length > 0) {
-              schemasToIntersect.push(z2.object(shape).passthrough());
+              schemasToIntersect.push(z3.object(shape).passthrough());
             }
             schemasToIntersect.push(...looseRecords);
             if (schemasToIntersect.length === 0) {
-              zodSchema = z2.object({}).passthrough();
+              zodSchema = z3.object({}).passthrough();
             } else if (schemasToIntersect.length === 1) {
               zodSchema = schemasToIntersect[0];
             } else {
-              let result = z2.intersection(schemasToIntersect[0], schemasToIntersect[1]);
+              let result = z3.intersection(schemasToIntersect[0], schemasToIntersect[1]);
               for (let i = 2; i < schemasToIntersect.length; i++) {
-                result = z2.intersection(result, schemasToIntersect[i]);
+                result = z3.intersection(result, schemasToIntersect[i]);
               }
               zodSchema = result;
             }
             break;
           }
-          const objectSchema = z2.object(shape);
+          const objectSchema = z3.object(shape);
           if (schema.additionalProperties === false) {
             zodSchema = objectSchema.strict();
           } else if (typeof schema.additionalProperties === "object") {
@@ -15432,33 +15432,33 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             const tupleItems = prefixItems.map((item) => convertSchema(item, ctx));
             const rest = items && typeof items === "object" && !Array.isArray(items) ? convertSchema(items, ctx) : void 0;
             if (rest) {
-              zodSchema = z2.tuple(tupleItems).rest(rest);
+              zodSchema = z3.tuple(tupleItems).rest(rest);
             } else {
-              zodSchema = z2.tuple(tupleItems);
+              zodSchema = z3.tuple(tupleItems);
             }
             if (typeof schema.minItems === "number") {
-              zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+              zodSchema = zodSchema.check(z3.minLength(schema.minItems));
             }
             if (typeof schema.maxItems === "number") {
-              zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+              zodSchema = zodSchema.check(z3.maxLength(schema.maxItems));
             }
           } else if (Array.isArray(items)) {
             const tupleItems = items.map((item) => convertSchema(item, ctx));
             const rest = schema.additionalItems && typeof schema.additionalItems === "object" ? convertSchema(schema.additionalItems, ctx) : void 0;
             if (rest) {
-              zodSchema = z2.tuple(tupleItems).rest(rest);
+              zodSchema = z3.tuple(tupleItems).rest(rest);
             } else {
-              zodSchema = z2.tuple(tupleItems);
+              zodSchema = z3.tuple(tupleItems);
             }
             if (typeof schema.minItems === "number") {
-              zodSchema = zodSchema.check(z2.minLength(schema.minItems));
+              zodSchema = zodSchema.check(z3.minLength(schema.minItems));
             }
             if (typeof schema.maxItems === "number") {
-              zodSchema = zodSchema.check(z2.maxLength(schema.maxItems));
+              zodSchema = zodSchema.check(z3.maxLength(schema.maxItems));
             }
           } else if (items !== void 0) {
             const element = convertSchema(items, ctx);
-            let arraySchema = z2.array(element);
+            let arraySchema = z3.array(element);
             if (typeof schema.minItems === "number") {
               arraySchema = arraySchema.min(schema.minItems);
             }
@@ -15467,7 +15467,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
             }
             zodSchema = arraySchema;
           } else {
-            zodSchema = z2.array(z2.any());
+            zodSchema = z3.array(z3.any());
           }
           break;
         }
@@ -15480,37 +15480,37 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     __name2(convertBaseSchema, "convertBaseSchema");
     function convertSchema(schema, ctx) {
       if (typeof schema === "boolean") {
-        return schema ? z2.any() : z2.never();
+        return schema ? z3.any() : z3.never();
       }
       let baseSchema = convertBaseSchema(schema, ctx);
       const hasExplicitType = schema.type || schema.enum !== void 0 || schema.const !== void 0;
       if (schema.anyOf && Array.isArray(schema.anyOf)) {
         const options = schema.anyOf.map((s) => convertSchema(s, ctx));
-        const anyOfUnion = z2.union(options);
-        baseSchema = hasExplicitType ? z2.intersection(baseSchema, anyOfUnion) : anyOfUnion;
+        const anyOfUnion = z3.union(options);
+        baseSchema = hasExplicitType ? z3.intersection(baseSchema, anyOfUnion) : anyOfUnion;
       }
       if (schema.oneOf && Array.isArray(schema.oneOf)) {
         const options = schema.oneOf.map((s) => convertSchema(s, ctx));
-        const oneOfUnion = z2.xor(options);
-        baseSchema = hasExplicitType ? z2.intersection(baseSchema, oneOfUnion) : oneOfUnion;
+        const oneOfUnion = z3.xor(options);
+        baseSchema = hasExplicitType ? z3.intersection(baseSchema, oneOfUnion) : oneOfUnion;
       }
       if (schema.allOf && Array.isArray(schema.allOf)) {
         if (schema.allOf.length === 0) {
-          baseSchema = hasExplicitType ? baseSchema : z2.any();
+          baseSchema = hasExplicitType ? baseSchema : z3.any();
         } else {
           let result = hasExplicitType ? baseSchema : convertSchema(schema.allOf[0], ctx);
           const startIdx = hasExplicitType ? 0 : 1;
           for (let i = startIdx; i < schema.allOf.length; i++) {
-            result = z2.intersection(result, convertSchema(schema.allOf[i], ctx));
+            result = z3.intersection(result, convertSchema(schema.allOf[i], ctx));
           }
           baseSchema = result;
         }
       }
       if (schema.nullable === true && ctx.version === "openapi-3.0") {
-        baseSchema = z2.nullable(baseSchema);
+        baseSchema = z3.nullable(baseSchema);
       }
       if (schema.readOnly === true) {
-        baseSchema = z2.readonly(baseSchema);
+        baseSchema = z3.readonly(baseSchema);
       }
       if (schema.default !== void 0) {
         baseSchema = baseSchema.default(schema.default);
@@ -15545,7 +15545,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
     __name2(convertSchema, "convertSchema");
     function fromJSONSchema(schema, params) {
       if (typeof schema === "boolean") {
-        return schema ? z2.any() : z2.never();
+        return schema ? z3.any() : z3.never();
       }
       let normalized;
       try {
@@ -16270,7 +16270,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       did: LCNProfileValidator.shape.did
     });
     var LCNConnectionProfileValidator = LCNAuthedProfileValidator.extend({
-      email: LCNProfileValidator.shape.email
+      email: LCNProfileValidator.shape.email,
+      connectedAt: external_exports.iso.datetime().optional().describe("When the viewer and this profile became connected.")
     });
     var LCNVisibleProfileValidator = external_exports.union([
       LCNConnectionProfileValidator.strict(),
@@ -17914,11 +17915,21 @@ var generateSrcSet3 = /* @__PURE__ */ __name((url, resolutions, { fix = false }
 
 // src/images/images.helpers.ts
 var Providers = { filestack: filestack_helpers_exports, unsplash: unsplash_helpers_exports, discord: discord_helpers_exports };
+var isHostnameMatch = /* @__PURE__ */ __name((hostname, target) => {
+  return hostname === target || hostname.endsWith(`.${target}`);
+}, "isHostnameMatch");
 var getProvider = /* @__PURE__ */ __name((url) => {
-  if (url?.includes("cdn.filestackcontent.com")) return "filestack";
-  if (url?.includes("images.unsplash.com")) return "unsplash";
-  if (url?.includes("cdn.discordapp.com")) return "discord";
-  return null;
+  if (!url) return null;
+  try {
+    const normalizedUrl = url.startsWith("//") ? `https:${url}` : url;
+    const { hostname } = new URL(normalizedUrl);
+    if (isHostnameMatch(hostname, "cdn.filestackcontent.com")) return "filestack";
+    if (isHostnameMatch(hostname, "images.unsplash.com")) return "unsplash";
+    if (isHostnameMatch(hostname, "cdn.discordapp.com")) return "discord";
+    return null;
+  } catch {
+    return null;
+  }
 }, "getProvider");
 var changeQuality4 = /* @__PURE__ */ __name((url, quality) => {
   const provider = getProvider(url);
@@ -17949,6 +17960,30 @@ var getUrlsFromSrcSet = /* @__PURE__ */ __name((srcSet) => {
   }, []);
 }, "getUrlsFromSrcSet");
 
+// src/images/sanitize.helpers.ts
+var sanitizeImageUrl = /* @__PURE__ */ __name((url, options = {}) => {
+  if (!url) return void 0;
+  const { allowBlobUrls = false, allowDataUrls = false } = options;
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:" || parsed.protocol === "http:") {
+      return parsed.href;
+    }
+    if (allowBlobUrls && parsed.protocol === "blob:") {
+      return parsed.href;
+    }
+    if (allowDataUrls && parsed.protocol === "data:") {
+      if (url.startsWith("data:image/")) {
+        return url;
+      }
+      return void 0;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}, "sanitizeImageUrl");
+
 // src/types/index.ts
 var isNotMaybe = /* @__PURE__ */ __name((value) => value !== void 0 && value !== null, "isNotMaybe");
 var filterMaybes = /* @__PURE__ */ __name((array) => array?.filter(isNotMaybe) ?? [], "filterMaybes");
@@ -18527,6 +18562,56 @@ var getDidWeb = /* @__PURE__ */ __name((domain, profileId) => {
   return `did:web:${encodeURIComponent(decodedDomain)}:users:${profileId}`;
 }, "getDidWeb");
 
+// src/environment.ts
+import { z as z2 } from "zod";
+var EnvironmentConfigurationError = class extends Error {
+  static {
+    __name(this, "EnvironmentConfigurationError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "EnvironmentConfigurationError";
+  }
+};
+var requiredEnvironmentString = z2.string().trim().min(1, "Required but missing");
+var optionalEnvironmentString = z2.preprocess(
+  (value) => value === "" ? void 0 : value,
+  requiredEnvironmentString.optional()
+);
+var optionalEnvironmentUrl = z2.preprocess(
+  (value) => value === "" ? void 0 : value,
+  z2.url("Expected a valid URL").optional()
+);
+var environmentBoolean = z2.enum(["true", "false", "1", "0"]).transform((value) => value === "true" || value === "1");
+var optionalEnvironmentBoolean = z2.preprocess(
+  (value) => value === "" || value === void 0 ? void 0 : value,
+  environmentBoolean.optional()
+);
+var environmentPort = z2.coerce.number().int().min(1).max(65535);
+var optionalEnvironmentPort = z2.preprocess(
+  (value) => value === "" || value === void 0 ? void 0 : value,
+  environmentPort.optional()
+);
+var parseEnvironment = /* @__PURE__ */ __name((schema, raw, context) => {
+  const result = schema.safeParse(raw);
+  if (result.success) return result.data;
+  const issues = result.error.issues.map((issue) => {
+    const key = issue.path.length ? issue.path.map(String).join(".") : "(environment)";
+    return `${key}
+  ${issue.message}`;
+  }).join("\n\n");
+  throw new EnvironmentConfigurationError(
+    [
+      `Invalid ${context.project} configuration`,
+      "",
+      issues,
+      "",
+      `Configuration source: ${context.source}`,
+      `Copy ${context.examplePath} to .env and correct the values above.`
+    ].join("\n")
+  );
+}, "parseEnvironment");
+
 // src/index.ts
 var isHex = /* @__PURE__ */ __name((str) => /^[0-9a-f]+$/i.test(str), "isHex");
 var isEncrypted = /* @__PURE__ */ __name((item) => {
@@ -18558,12 +18643,9 @@ var RegExpTransformer = {
   }
 };
 var isVC2Format = /* @__PURE__ */ __name((credential) => {
-  if (!credential["@context"] || !Array.isArray(credential["@context"])) {
-    return false;
-  }
-  return credential["@context"].some(
-    (context) => context === "https://www.w3.org/ns/credentials/v2"
-  );
+  if (!credential || typeof credential !== "object" || !("@context" in credential)) return false;
+  const context = credential["@context"];
+  return Array.isArray(context) ? context.some((value) => value === "https://www.w3.org/ns/credentials/v2") : context === "https://www.w3.org/ns/credentials/v2";
 }, "isVC2Format");
 var unwrapBoostCredential = /* @__PURE__ */ __name((vc) => {
   if (vc?.type?.includes("CertifiedBoostCredential") && vc?.boostCredential) {
@@ -18580,6 +18662,7 @@ var isAppDidWeb = /* @__PURE__ */ __name((did) => {
 export {
   AGE_RATING_TO_MIN_AGE,
   DEFAULT_RESOLUTIONS,
+  EnvironmentConfigurationError,
   ImageResizingValidator,
   ImageUploadingValidator,
   ImageWithLoadingStateValdator,
@@ -18597,6 +18680,8 @@ export {
   deriveNameFromVct,
   deriveSdJwtIssuedAtIso,
   deriveTypeFromVct,
+  environmentBoolean,
+  environmentPort,
   extractVctSegment,
   filterMaybes,
   filterUndefined,
@@ -18622,10 +18707,17 @@ export {
   isNotMaybe,
   isNotUndefined,
   isVC2Format,
+  optionalEnvironmentBoolean,
+  optionalEnvironmentPort,
+  optionalEnvironmentString,
+  optionalEnvironmentUrl,
+  parseEnvironment,
   projectEnvelopeToDisplayVc,
   quantizeValue,
+  requiredEnvironmentString,
   resizeAndChangeQuality4 as resizeAndChangeQuality,
   resolveStorageReadResult,
+  sanitizeImageUrl,
   setBitstringStatusListBit,
   stripSdJwtReservedClaims,
   synthesizeDidJwk,