@arrirpc/schema 0.54.0 → 0.57.0

package/dist/shared/{schema.4c9064ee.cjs → schema.e933693f.cjs}

@@ -79,8 +79,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 {
@@ -89,8 +89,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 {
@@ -117,24 +117,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
               })
             );
           }
@@ -221,7 +221,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;
           }
@@ -237,10 +237,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;
         }
@@ -369,12 +369,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 = [];
@@ -423,22 +423,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
           });
@@ -561,35 +564,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}"`;
@@ -869,8 +872,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()}"`;
@@ -926,8 +929,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()}"`;
@@ -1062,11 +1065,11 @@ function object(propA, propB) {
       isDeprecated: opts.isDeprecated,
       [SCHEMA_METADATA]: {
         output: {},
-        parse(input2, data) {
+        parse(input2, context) {
           return parseObjectSchema(
             schema,
             input2,
-            data,
+            context,
             false
           );
         },
@@ -1081,11 +1084,11 @@ function object(propA, propB) {
         validate(input2) {
           return validateObjectSchema(schema, input2);
         },
-        serialize(input2, data) {
+        serialize(input2, context) {
           return serializeObject(
             schema,
             input2,
-            data
+            context
           );
         }
       }
@@ -1234,17 +1237,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);
         }
       }
     }
@@ -1290,11 +1303,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
+          );
         }
       }
     }
@@ -1355,15 +1373,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);
       }
     }
   };
@@ -1400,14 +1418,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);
       }
     }
   };
@@ -1437,26 +1465,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;
@@ -1519,14 +1547,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 "";
         },
@@ -1536,9 +1564,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);
           }
         }
       }
@@ -1568,8 +1596,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) {

package/dist/testSuites.cjs

@@ -2,7 +2,7 @@
 
 require('jtd-utils');
 require('scule');
-const timestamp = require('./shared/schema.4c9064ee.cjs');
+const timestamp = require('./shared/schema.e933693f.cjs');
 
 const User = timestamp.object({
   id: timestamp.string(),

package/dist/testSuites.d.cts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.cjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.cjs';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.d.mts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.mjs';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.mjs';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.d.ts

@@ -1,4 +1,4 @@
-import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.7414d46a.js';
+import { d as AObjectSchema, e as ADiscriminatorSchema, A as ASchema } from './shared/schema.16e4d5ba.js';
 import 'jtd-utils';
 
 type RecursiveUnion = {

package/dist/testSuites.mjs

@@ -1,6 +1,6 @@
 import 'jtd-utils';
 import 'scule';
-import { K as object, W as string, M as optional, I as nullable, F as int32, z as discriminator, w as boolean, X as stringEnum, v as array, Y as timestamp, _ as uint32, t as any, J as number, Q as record, R as recursive, D as float64, C as float32, G as int64, E as int16, Z as uint16, H as int8, a0 as uint8, O as partial, $ as uint64, P as pick, A as enumerator } from './shared/schema.79ea38f8.mjs';
+import { K as object, W as string, M as optional, I as nullable, F as int32, z as discriminator, w as boolean, X as stringEnum, v as array, Y as timestamp, _ as uint32, t as any, J as number, Q as record, R as recursive, D as float64, C as float32, G as int64, E as int16, Z as uint16, H as int8, a0 as uint8, O as partial, $ as uint64, P as pick, A as enumerator } from './shared/schema.8f2f6fef.mjs';
 
 const User = object({
   id: string(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arrirpc/schema",
-  "version": "0.54.0",
+  "version": "0.57.0",
   "type": "module",
   "license": "MIT",
   "author": {
@@ -24,11 +24,11 @@
   "dependencies": {
     "scule": "^1.3.0",
     "uncrypto": "^0.1.3",
-    "jtd-utils": "0.54.0"
+    "jtd-utils": "0.57.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^8.4.1",
-    "ajv": "^8.16.0",
+    "ajv": "^8.17.1",
     "benny": "^3.7.1"
   }
 }