@reboot-dev/reboot 0.41.0 → 0.43.0

package/version.d.ts

@@ -1 +1 @@
-export declare const REBOOT_VERSION = "0.41.0";
+export declare const REBOOT_VERSION = "0.43.0";

package/version.js

@@ -1 +1 @@
-export const REBOOT_VERSION = "0.41.0";
+export const REBOOT_VERSION = "0.43.0";

package/zod-to-proto.js

@@ -262,85 +262,85 @@ const generate = (proto, { schema, path, name, state = false, }) => {
         proto.write(`map <string, ${typeName}> record = 1;`);
     }
     else if (schema instanceof z.ZodArray) {
-        const element = schema.element;
-        if (element instanceof z.ZodOptional) {
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has _optional_ element type which is not supported`));
+        const item = schema.element;
+        if (item instanceof z.ZodOptional) {
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has _optional_ item type which is not supported`));
             process.exit(-1);
         }
-        else if (element instanceof z.ZodDefault) {
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has _default_ element type which is not supported`));
+        else if (item instanceof z.ZodDefault) {
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has _default_ item type which is not supported`));
             process.exit(-1);
         }
         const typeName = (() => {
             // To account for all possible "string" types in Zod, e.g.,
             // `z.uuid()`, `z.email()`, etc, we can't use `instanceof`.
-            if (element._zod.def.type === "string") {
+            if (item._zod.def.type === "string") {
                 return "string";
             }
-            else if (element instanceof z.ZodNumber) {
+            else if (item instanceof z.ZodNumber) {
                 return "double";
             }
-            else if (element instanceof z.ZodBigInt) {
+            else if (item instanceof z.ZodBigInt) {
                 return "int64";
             }
-            else if (element instanceof z.ZodBoolean) {
+            else if (item instanceof z.ZodBoolean) {
                 return "bool";
             }
-            else if (element instanceof z.ZodObject) {
-                return "Element";
+            else if (item instanceof z.ZodObject) {
+                return "Item";
             }
-            else if (element instanceof z.ZodRecord) {
-                return "Element";
+            else if (item instanceof z.ZodRecord) {
+                return "Item";
             }
-            else if (element instanceof z.ZodArray) {
-                return "Element";
+            else if (item instanceof z.ZodArray) {
+                return "Item";
             }
-            else if (element instanceof z.ZodDiscriminatedUnion) {
-                return "Element";
+            else if (item instanceof z.ZodDiscriminatedUnion) {
+                return "Item";
             }
-            else if (element instanceof z.ZodCustom) {
-                const meta = element.meta();
-                if (element instanceof z.ZodCustom && "protobuf" in meta) {
+            else if (item instanceof z.ZodCustom) {
+                const meta = item.meta();
+                if (item instanceof z.ZodCustom && "protobuf" in meta) {
                     return meta.protobuf;
                 }
             }
-            else if (iszjson(element)) {
+            else if (iszjson(item)) {
                 return "google.protobuf.Value";
             }
-            console.error(chalk.stderr.bold.red(`Array at '${path}' has element type '${element._zod.def.type}' which is not (yet) supported`));
+            console.error(chalk.stderr.bold.red(`Array at '${path}' has item type '${item._zod.def.type}' which is not (yet) supported`));
             process.exit(-1);
         })();
-        if (element instanceof z.ZodObject) {
+        if (item instanceof z.ZodObject) {
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
                 name: typeName,
             });
         }
-        else if (element instanceof z.ZodRecord) {
+        else if (item instanceof z.ZodRecord) {
             proto.write(`message ${typeName} {`);
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
             });
             proto.write(`}`);
         }
-        else if (element instanceof z.ZodArray) {
+        else if (item instanceof z.ZodArray) {
             proto.write(`message ${typeName} {`);
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
             });
             proto.write(`}`);
         }
-        else if (element instanceof z.ZodDiscriminatedUnion) {
+        else if (item instanceof z.ZodDiscriminatedUnion) {
             generate(proto, {
-                schema: element,
-                path: `${path}.[element]`,
+                schema: item,
+                path: `${path}.[item]`,
                 name: typeName,
             });
         }
-        proto.write(`repeated ${typeName} elements = 1;`);
+        proto.write(`repeated ${typeName} items = 1;`);
     }
     else if (schema instanceof z.ZodDiscriminatedUnion) {
         assert(name !== undefined);