@arrirpc/schema 0.55.0 → 0.57.0

package/dist/shared/{schema.79ea38f8.mjs → schema.8f2f6fef.mjs}

@@ -77,8 +77,8 @@ function any(options = {}) {
       isDeprecated: options.isDeprecated,
       [SCHEMA_METADATA]: {
         output: void 0,
-        parse: (input, data) => {
-          if (data.instancePath.length === 0 && typeof input === "string") {
+        parse: (input, context) => {
+          if (context.instancePath.length === 0 && typeof input === "string") {
             try {
               return JSON.parse(input);
             } catch {
@@ -87,8 +87,8 @@ function any(options = {}) {
           }
           return input;
         },
-        coerce: (input, data) => {
-          if (data.instancePath.length === 0 && typeof input === "string") {
+        coerce: (input, context) => {
+          if (context.instancePath.length === 0 && typeof input === "string") {
             try {
               return JSON.parse(input);
             } catch {
@@ -115,24 +115,24 @@ function array(schema, opts = {}) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: [],
-        parse(input, data) {
-          return parse$6(schema, input, data, false);
+        parse(input, context) {
+          return parse$6(schema, input, context, false);
         },
-        coerce(input, data) {
-          return parse$6(schema, input, data, true);
+        coerce(input, context) {
+          return parse$6(schema, input, context, true);
         },
         validate(input) {
           return validate$5(schema, input);
         },
-        serialize(input, data) {
+        serialize(input, context) {
           const strParts = [];
           for (let i = 0; i < input.length; i++) {
             const item = input[i];
             strParts.push(
               schema.metadata[SCHEMA_METADATA].serialize(item, {
-                instancePath: `${data.instancePath}/${i}`,
-                schemaPath: `${data.schemaPath}/elements`,
-                errors: data.errors
+                instancePath: `${context.instancePath}/${i}`,
+                schemaPath: `${context.schemaPath}/elements`,
+                errors: context.errors
               })
             );
           }
@@ -219,7 +219,7 @@ function boolean(opts = {}) {
         parse: parse$5,
         validate: validate$4,
         serialize: serialize$2,
-        coerce(input, data) {
+        coerce(input, context) {
           if (validate$4(input)) {
             return input;
           }
@@ -235,10 +235,10 @@ function boolean(opts = {}) {
             case 0:
               return false;
           }
-          data.errors.push({
-            instancePath: data.instancePath,
-            schemaPath: data.schemaPath,
-            message: `Error at ${data.instancePath}. Unable to coerce ${input} to boolean.`
+          context.errors.push({
+            instancePath: context.instancePath,
+            schemaPath: context.schemaPath,
+            message: `Error at ${context.instancePath}. Unable to coerce ${input} to boolean.`
           });
           return void 0;
         }
@@ -367,12 +367,12 @@ function safeCoerce(schema, input) {
   }
 }
 function serialize$1(schema, input) {
-  const data = {
+  const context = {
     instancePath: "",
     schemaPath: "",
     errors: []
   };
-  return schema.metadata[SCHEMA_METADATA].serialize(input, data);
+  return schema.metadata[SCHEMA_METADATA].serialize(input, context);
 }
 function errors(schema, input) {
   const errorList = [];
@@ -421,22 +421,25 @@ function discriminator(propA, propB, propC) {
         validate(input) {
           return validate$2(discriminator2, mapping, input);
         },
-        parse(input, data) {
-          return parse$3(discriminator2, mapping, input, data, false);
+        parse(input, context) {
+          return parse$3(discriminator2, mapping, input, context, false);
         },
-        coerce: (input, data) => {
-          return parse$3(discriminator2, mapping, input, data, true);
+        coerce: (input, context) => {
+          return parse$3(discriminator2, mapping, input, context, true);
         },
-        serialize(input, data) {
+        serialize(input, context) {
           const discriminatorVal = input[discriminator2] ?? "";
           const targetSchema = mapping[discriminatorVal];
           if (!targetSchema) {
-            throw discriminatorMappingError(discriminatorVal, data);
+            throw discriminatorMappingError(
+              discriminatorVal,
+              context
+            );
           }
           const result = targetSchema.metadata[SCHEMA_METADATA].serialize(input, {
-            instancePath: data.instancePath,
-            schemaPath: `${data.schemaPath}/mapping/${discriminatorVal}`,
-            errors: data.errors,
+            instancePath: context.instancePath,
+            schemaPath: `${context.schemaPath}/mapping/${discriminatorVal}`,
+            errors: context.errors,
             discriminatorKey: discriminator2,
             discriminatorValue: discriminatorVal
           });
@@ -559,35 +562,35 @@ function enumerator(paramA, paramB) {
       isDeprecated: meta?.isDeprecated,
       [SCHEMA_METADATA]: {
         output: paramA[0] ?? "",
-        parse(input, data) {
+        parse(input, context) {
           if (isType(input)) {
             return input;
           }
-          data.errors.push({
-            instancePath: data.instancePath,
-            schemaPath: `${data.schemaPath}/enum`,
-            message: `Error at ${data.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+          context.errors.push({
+            instancePath: context.instancePath,
+            schemaPath: `${context.schemaPath}/enum`,
+            message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
               ", "
             )}]`
           });
           return void 0;
         },
-        coerce: (input, data) => {
+        coerce: (input, context) => {
           if (isType(input)) {
             return input;
           }
-          data.errors.push({
-            instancePath: data.instancePath,
-            schemaPath: `${data.schemaPath}/enum`,
-            message: `Error at ${data.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
+          context.errors.push({
+            instancePath: context.instancePath,
+            schemaPath: `${context.schemaPath}/enum`,
+            message: `Error at ${context.instancePath}. Invalid enum value. Expected one of the following values: [${enumVal.join(
               ", "
             )}]`
           });
           return void 0;
         },
         validate: isType,
-        serialize(input, data) {
-          if (data.instancePath.length === 0) {
+        serialize(input, context) {
+          if (context.instancePath.length === 0) {
             return input;
           }
           return `"${input}"`;
@@ -867,8 +870,8 @@ function int64(opts = {}) {
         validate: isType,
         parse,
         coerce: parse,
-        serialize(input, data) {
-          if (data.instancePath.length === 0) {
+        serialize(input, context) {
+          if (context.instancePath.length === 0) {
             return input.toString();
           }
           return `"${input.toString()}"`;
@@ -924,8 +927,8 @@ function uint64(opts = {}) {
         validate: isType,
         parse,
         coerce: parse,
-        serialize(input, data) {
-          if (data.instancePath.length === 0) {
+        serialize(input, context) {
+          if (context.instancePath.length === 0) {
             return input.toString();
           }
           return `"${input.toString()}"`;
@@ -1060,11 +1063,11 @@ function object(propA, propB) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse(input2, data) {
+        parse(input2, context) {
           return parseObjectSchema(
             schema,
             input2,
-            data,
+            context,
             false
           );
         },
@@ -1079,11 +1082,11 @@ function object(propA, propB) {
         validate(input2) {
           return validateObjectSchema(schema, input2);
         },
-        serialize(input2, data) {
+        serialize(input2, context) {
           return serializeObject(
             schema,
             input2,
-            data
+            context
           );
         }
       }
@@ -1232,17 +1235,27 @@ function pick(inputSchema, keys, opts = {}) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse: (input, data) => {
-          return parseObjectSchema(schema, input, data, true);
+        parse: (input, context) => {
+          return parseObjectSchema(
+            schema,
+            input,
+            context,
+            true
+          );
         },
-        coerce(input, data) {
-          return parseObjectSchema(schema, input, data, false);
+        coerce(input, context) {
+          return parseObjectSchema(
+            schema,
+            input,
+            context,
+            false
+          );
         },
         validate(input) {
           return validateObjectSchema(schema, input);
         },
-        serialize(input, data) {
-          return serializeObject(schema, input, data);
+        serialize(input, context) {
+          return serializeObject(schema, input, context);
         }
       }
     }
@@ -1288,11 +1301,16 @@ function omit(inputSchema, keys, opts = {}) {
         parse(input, data) {
           return parseObjectSchema(schema, input, data, false);
         },
-        serialize(input, data) {
-          return serializeObject(schema, input, data);
+        serialize(input, context) {
+          return serializeObject(schema, input, context);
         },
-        coerce(input, data) {
-          return parseObjectSchema(schema, input, data, true);
+        coerce(input, context) {
+          return parseObjectSchema(
+            schema,
+            input,
+            context,
+            true
+          );
         }
       }
     }
@@ -1353,15 +1371,15 @@ function extend(baseSchema, inputSchema, opts = {}) {
     description: opts.description,
     [SCHEMA_METADATA]: {
       output: {},
-      parse(input, data) {
-        return parseObjectSchema(schema, input, data, false);
+      parse(input, context) {
+        return parseObjectSchema(schema, input, context, false);
       },
-      coerce(input, data) {
-        return parseObjectSchema(schema, input, data, true);
+      coerce(input, context) {
+        return parseObjectSchema(schema, input, context, true);
       },
       validate: isType,
-      serialize(input, data) {
-        return serializeObject(schema, input, data);
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
       }
     }
   };
@@ -1398,14 +1416,24 @@ function partial(schema, options = {}) {
       validate(input) {
         return validateObjectSchema(newSchema, input);
       },
-      parse(input, data) {
-        return parseObjectSchema(newSchema, input, data, false);
+      parse(input, context) {
+        return parseObjectSchema(
+          newSchema,
+          input,
+          context,
+          false
+        );
       },
-      coerce(input, data) {
-        return parseObjectSchema(newSchema, input, data, true);
+      coerce(input, context) {
+        return parseObjectSchema(
+          newSchema,
+          input,
+          context,
+          true
+        );
       },
-      serialize(input, data) {
-        return serializeObject(schema, input, data);
+      serialize(input, context) {
+        return serializeObject(schema, input, context);
       }
     }
   };
@@ -1435,26 +1463,26 @@ function record(schema, opts = {}) {
           }
           return true;
         },
-        parse(input, data) {
-          return parse$2(schema, input, data, false);
+        parse(input, context) {
+          return parse$2(schema, input, context, false);
         },
         coerce(input, data) {
           return parse$2(schema, input, data, true);
         },
-        serialize(input, data) {
+        serialize(input, context) {
           const strParts = [];
           for (const key of Object.keys(input)) {
             const val = input[key];
             strParts.push(
               `"${key}":${schema.metadata[SCHEMA_METADATA].serialize(val, {
-                instancePath: `${data.instancePath}/${key}`,
-                schemaPath: `${data.schemaPath}/values`,
-                errors: data.errors
+                instancePath: `${context.instancePath}/${key}`,
+                schemaPath: `${context.schemaPath}/values`,
+                errors: context.errors
               })}`
             );
           }
           const result = `{${strParts.join(",")}}`;
-          if (data.instancePath.length === 0) {
+          if (context.instancePath.length === 0) {
             return sanitizeJson(result);
           }
           return result;
@@ -1517,14 +1545,14 @@ function recursive(propA, propB) {
     metadata: {
       [SCHEMA_METADATA]: {
         output: "",
-        parse(input, data) {
+        parse(input, context) {
           if (recursiveFns[id]) {
-            return recursiveFns[id].parse(input, data);
+            return recursiveFns[id].parse(input, context);
           }
         },
-        serialize(input, data) {
+        serialize(input, context) {
           if (recursiveFns[id]) {
-            return recursiveFns[id].serialize(input, data);
+            return recursiveFns[id].serialize(input, context);
           }
           return "";
         },
@@ -1534,9 +1562,9 @@ function recursive(propA, propB) {
           }
           return false;
         },
-        coerce(input, data) {
+        coerce(input, context) {
           if (recursiveFns[id]) {
-            return recursiveFns[id].coerce(input, data);
+            return recursiveFns[id].coerce(input, context);
           }
         }
       }
@@ -1566,8 +1594,8 @@ function string(opts = {}) {
         parse: parse$1,
         coerce: coerce$1,
         validate: validate$1,
-        serialize(input, data) {
-          if (data.instancePath.length === 0) {
+        serialize(input, context) {
+          if (context.instancePath.length === 0) {
             return input;
           }
           if (input.length < 42) {
@@ -1684,4 +1712,4 @@ function serialize(input, data) {
   return `"${input.toISOString()}"`;
 }
 
-export { uint64 as $, enumerator as A, extend as B, float32 as C, float64 as D, int16 as E, int32 as F, int64 as G, int8 as H, nullable as I, number as J, object as K, omit as L, optional as M, parse$4 as N, partial as O, pick as P, record as Q, recursive as R, safeCoerce as S, safeParse as T, serialize$1 as U, ValidationError as V, string as W, stringEnum as X, timestamp as Y, uint16 as Z, uint32 as _, uint8Min as a, uint8 as a0, validate$3 as a1, isASchema as a2, SCHEMA_METADATA as a3, int64Min as a4, int64Max as a5, uint64Min as a6, uint64Max as a7, parseObjectSchema as a8, validateObjectSchema as a9, serializeObject as aa, serializeSmallString as ab, sanitizeJson as ac, isValidationError as ad, NumberTypeValues as ae, isObject as af, uint16Max as b, uint16Min as c, uint32Max as d, uint32Min as e, int8Min as f, int16Max as g, int16Min as h, int8Max as i, int32Max as j, int32Min as k, isAScalarSchema as l, isAObjectSchema as m, isAStringEnumSchema as n, isAAraySchema as o, isARecordSchema as p, isADiscriminatorSchema as q, isARefSchema as r, errors as s, any as t, uint8Max as u, array as v, boolean as w, clone as x, coerce$2 as y, discriminator as z };
+export { uint64 as $, enumerator as A, extend as B, float32 as C, float64 as D, int16 as E, int32 as F, int64 as G, int8 as H, nullable as I, number as J, object as K, omit as L, optional as M, parse$4 as N, partial as O, pick as P, record as Q, recursive as R, safeCoerce as S, safeParse as T, serialize$1 as U, ValidationError as V, string as W, stringEnum as X, timestamp as Y, uint16 as Z, uint32 as _, uint8Min as a, uint8 as a0, validate$3 as a1, SCHEMA_METADATA as a2, int64Min as a3, int64Max as a4, uint64Min as a5, uint64Max as a6, parseObjectSchema as a7, validateObjectSchema as a8, serializeObject as a9, serializeSmallString as aa, sanitizeJson as ab, isValidationError as ac, isASchema as ad, NumberTypeValues as ae, isObject as af, uint16Max as b, uint16Min as c, uint32Max as d, uint32Min as e, int8Min as f, int16Max as g, int16Min as h, int8Max as i, int32Max as j, int32Min as k, isAScalarSchema as l, isAObjectSchema as m, isAStringEnumSchema as n, isAAraySchema as o, isARecordSchema as p, isADiscriminatorSchema as q, isARefSchema as r, errors as s, any as t, uint8Max as u, array as v, boolean as w, clone as x, coerce$2 as y, discriminator as z };