jazz-tools 0.15.16 → 0.16.0

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchema.ts

@@ -1,113 +1,121 @@
 import { JsonValue } from "cojson";
 import {
   Account,
+  AnyZodOrCoValueSchema,
+  CoDiscriminatedUnionSchema,
   CoFeed,
   CoList,
   CoMap,
   CoPlainText,
   CoRichText,
   CoValueClass,
+  CoreAccountSchema,
+  CoreCoRecordSchema,
   FileStream,
   Profile,
 } from "../../../internal.js";
-import { AnyCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
-import { AnyCoListSchema } from "../schemaTypes/CoListSchema.js";
-import { AnyCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { FileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { CoreCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
+import { CoreCoListSchema } from "../schemaTypes/CoListSchema.js";
+import { CoreCoMapSchema } from "../schemaTypes/CoMapSchema.js";
+import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
+import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
+import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
 
 export type InstanceOrPrimitiveOfSchema<
-  S extends CoValueClass | z.core.$ZodType,
-> = S extends z.core.$ZodType
-  ? S extends z.core.$ZodObject<infer Shape> & {
-      collaborative: true;
-      builtin: "Account";
-    }
+  S extends CoValueClass | AnyZodOrCoValueSchema,
+> = S extends CoreCoValueSchema
+  ? S extends CoreAccountSchema<infer Shape>
     ? {
         -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<Shape[key]>;
       } & { profile: Profile } & Account
-    : S extends z.core.$ZodRecord<infer K, infer V> & {
-          collaborative: true;
-        }
+    : S extends CoreCoRecordSchema<infer K, infer V>
       ? {
           -readonly [key in z.output<K> &
             string]: InstanceOrPrimitiveOfSchema<V>;
         } & CoMap
-      : S extends AnyCoMapSchema<infer Shape, infer Config>
+      : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
         ? {
             -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
               Shape[key]
             >;
-          } & (unknown extends Config["out"][string]
+          } & (unknown extends CatchAll
             ? {}
             : {
-                [key: string]: Config["out"][string];
+                // @ts-expect-error
+                [key: string]: InstanceOrPrimitiveOfSchema<CatchAll>;
               }) &
             CoMap
-        : S extends AnyCoListSchema<infer T>
+        : S extends CoreCoListSchema<infer T>
           ? CoList<InstanceOrPrimitiveOfSchema<T>>
-          : S extends AnyCoFeedSchema<infer T>
+          : S extends CoreCoFeedSchema<infer T>
             ? CoFeed<InstanceOrPrimitiveOfSchema<T>>
-            : S extends PlainTextSchema
+            : S extends CorePlainTextSchema
               ? CoPlainText
-              : S extends RichTextSchema
+              : S extends CoreRichTextSchema
                 ? CoRichText
-                : S extends FileStreamSchema
+                : S extends CoreFileStreamSchema
                   ? FileStream
-                  : S extends z.core.$ZodOptional<infer Inner>
-                    ? InstanceOrPrimitiveOfSchema<Inner> | undefined
-                    : S extends z.ZodJSONSchema
-                      ? JsonValue
-                      : S extends z.core.$ZodUnion<infer Members>
-                        ? InstanceOrPrimitiveOfSchema<Members[number]>
-                        : // primitives below here - we manually traverse to ensure we only allow what we can handle
-                          S extends z.core.$ZodObject<infer Shape>
-                          ? {
-                              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                                Shape[key]
-                              >;
-                            }
-                          : S extends z.core.$ZodArray<infer Item>
-                            ? InstanceOrPrimitiveOfSchema<Item>[]
-                            : S extends z.core.$ZodTuple<infer Items>
-                              ? {
-                                  [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                                    Items[key]
-                                  >;
-                                }
-                              : S extends z.core.$ZodString
-                                ? string
-                                : S extends z.core.$ZodNumber
-                                  ? number
-                                  : S extends z.core.$ZodBoolean
-                                    ? boolean
-                                    : S extends z.core.$ZodLiteral<
-                                          infer Literal
-                                        >
-                                      ? Literal
-                                      : S extends z.core.$ZodDate
-                                        ? Date
-                                        : S extends z.core.$ZodEnum<infer Enum>
-                                          ? Enum[keyof Enum]
-                                          : S extends z.core.$ZodTemplateLiteral<
-                                                infer pattern
-                                              >
-                                            ? pattern
-                                            : S extends z.core.$ZodReadonly<
-                                                  infer Inner
-                                                >
-                                              ? InstanceOrPrimitiveOfSchema<Inner>
-                                              : S extends z.core.$ZodDefault<
-                                                    infer Default
-                                                  >
-                                                ? InstanceOrPrimitiveOfSchema<Default>
-                                                : S extends z.core.$ZodCatch<
-                                                      infer Catch
-                                                    >
-                                                  ? InstanceOrPrimitiveOfSchema<Catch>
-                                                  : never
-  : S extends CoValueClass
-    ? InstanceType<S>
-    : never;
+                  : S extends CoreCoOptionalSchema<infer T>
+                    ? InstanceOrPrimitiveOfSchema<T> | undefined
+                    : S extends CoDiscriminatedUnionSchema<infer Members>
+                      ? InstanceOrPrimitiveOfSchema<Members[number]>
+                      : never
+  : S extends z.core.$ZodType
+    ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
+      ? InstanceOrPrimitiveOfSchema<Inner> | undefined
+      : S extends z.ZodJSONSchema
+        ? JsonValue
+        : S extends z.core.$ZodUnion<infer Members extends z.core.$ZodType[]>
+          ? InstanceOrPrimitiveOfSchema<Members[number]>
+          : // primitives below here - we manually traverse to ensure we only allow what we can handle
+            S extends z.core.$ZodObject<infer Shape>
+            ? {
+                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                  Shape[key]
+                >;
+              }
+            : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
+              ? InstanceOrPrimitiveOfSchema<Item>[]
+              : S extends z.core.$ZodTuple<
+                    infer Items extends readonly z.core.$ZodType[]
+                  >
+                ? {
+                    [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                      Items[key]
+                    >;
+                  }
+                : S extends z.core.$ZodString
+                  ? string
+                  : S extends z.core.$ZodNumber
+                    ? number
+                    : S extends z.core.$ZodBoolean
+                      ? boolean
+                      : S extends z.core.$ZodLiteral<infer Literal>
+                        ? Literal
+                        : S extends z.core.$ZodDate
+                          ? Date
+                          : S extends z.core.$ZodEnum<infer Enum>
+                            ? Enum[keyof Enum]
+                            : S extends z.core.$ZodTemplateLiteral<
+                                  infer pattern
+                                >
+                              ? pattern
+                              : S extends z.core.$ZodReadonly<
+                                    infer Inner extends z.core.$ZodType
+                                  >
+                                ? InstanceOrPrimitiveOfSchema<Inner>
+                                : S extends z.core.$ZodDefault<
+                                      infer Default extends z.core.$ZodType
+                                    >
+                                  ? InstanceOrPrimitiveOfSchema<Default>
+                                  : S extends z.core.$ZodCatch<
+                                        infer Catch extends z.core.$ZodType
+                                      >
+                                    ? InstanceOrPrimitiveOfSchema<Catch>
+                                    : never
+    : S extends CoValueClass
+      ? InstanceType<S>
+      : never;

package/src/tools/implementation/zodSchema/typeConverters/InstanceOrPrimitiveOfSchemaCoValuesNullable.ts

@@ -1,31 +1,34 @@
 import { JsonValue } from "cojson";
 import {
   Account,
+  AnyZodOrCoValueSchema,
+  CoDiscriminatedUnionSchema,
   CoFeed,
   CoList,
   CoMap,
   CoPlainText,
   CoRichText,
   CoValueClass,
+  CoreAccountSchema,
+  CoreCoRecordSchema,
   FileStream,
   InstanceOrPrimitiveOfSchema,
   Profile,
 } from "../../../internal.js";
-import { AnyCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
-import { AnyCoListSchema } from "../schemaTypes/CoListSchema.js";
-import { AnyCoMapSchema } from "../schemaTypes/CoMapSchema.js";
-import { FileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
-import { PlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
-import { RichTextSchema } from "../schemaTypes/RichTextSchema.js";
+import { CoreCoFeedSchema } from "../schemaTypes/CoFeedSchema.js";
+import { CoreCoListSchema } from "../schemaTypes/CoListSchema.js";
+import { CoreCoMapSchema } from "../schemaTypes/CoMapSchema.js";
+import { CoreCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
+import { CoreCoValueSchema } from "../schemaTypes/CoValueSchema.js";
+import { CoreFileStreamSchema } from "../schemaTypes/FileStreamSchema.js";
+import { CorePlainTextSchema } from "../schemaTypes/PlainTextSchema.js";
+import { CoreRichTextSchema } from "../schemaTypes/RichTextSchema.js";
 import { z } from "../zodReExport.js";
 
 export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
-  S extends CoValueClass | z.core.$ZodType,
-> = S extends z.core.$ZodType
-  ? S extends z.core.$ZodObject<infer Shape> & {
-      collaborative: true;
-      builtin: "Account";
-    }
+  S extends CoValueClass | AnyZodOrCoValueSchema,
+> = S extends CoreCoValueSchema
+  ? S extends CoreAccountSchema<infer Shape>
     ?
         | ({
             -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
@@ -33,94 +36,100 @@ export type InstanceOrPrimitiveOfSchemaCoValuesNullable<
             >;
           } & { profile: Profile | null } & Account)
         | null
-    : S extends z.core.$ZodRecord<infer K, infer V> & {
-          collaborative: true;
-        }
+    : S extends CoreCoRecordSchema<infer K, infer V>
       ?
           | ({
               -readonly [key in z.output<K> &
                 string]: InstanceOrPrimitiveOfSchemaCoValuesNullable<V>;
             } & CoMap)
           | null
-      : S extends AnyCoMapSchema<infer Shape, infer Config>
+      : S extends CoreCoMapSchema<infer Shape, infer CatchAll>
         ?
             | ({
                 -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchemaCoValuesNullable<
                   Shape[key]
                 >;
-              } & (unknown extends Config["out"][string]
+              } & (unknown extends CatchAll
                 ? {}
                 : {
-                    [key: string]: Config["out"][string];
+                    [
+                      key: string // @ts-expect-error
+                    ]: InstanceOrPrimitiveOfSchemaCoValuesNullable<CatchAll>;
                   }) &
                 CoMap)
             | null
-        : S extends AnyCoListSchema<infer T>
+        : S extends CoreCoListSchema<infer T>
           ? CoList<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-          : S extends AnyCoFeedSchema<infer T>
+          : S extends CoreCoFeedSchema<infer T>
             ? CoFeed<InstanceOrPrimitiveOfSchemaCoValuesNullable<T>> | null
-            : S extends PlainTextSchema
+            : S extends CorePlainTextSchema
               ? CoPlainText | null
-              : S extends RichTextSchema
+              : S extends CoreRichTextSchema
                 ? CoRichText | null
-                : S extends FileStreamSchema
+                : S extends CoreFileStreamSchema
                   ? FileStream | null
-                  : S extends z.core.$ZodOptional<infer Inner>
-                    ?
-                        | InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner>
-                        | undefined
-                    : S extends z.ZodJSONSchema
-                      ? JsonValue
-                      : S extends z.core.$ZodUnion<infer Members>
-                        ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
-                            Members[number]
-                          >
-                        : // primitives below here - we manually traverse to ensure we only allow what we can handle
-                          S extends z.core.$ZodObject<infer Shape>
-                          ? {
-                              -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
-                                Shape[key]
-                              >;
-                            }
-                          : S extends z.core.$ZodArray<infer Item>
-                            ? InstanceOrPrimitiveOfSchema<Item>[]
-                            : S extends z.core.$ZodTuple<infer Items>
-                              ? {
-                                  [key in keyof Items]: InstanceOrPrimitiveOfSchema<
-                                    Items[key]
-                                  >;
-                                }
-                              : S extends z.core.$ZodString
-                                ? string
-                                : S extends z.core.$ZodNumber
-                                  ? number
-                                  : S extends z.core.$ZodBoolean
-                                    ? boolean
-                                    : S extends z.core.$ZodLiteral<
-                                          infer Literal
-                                        >
-                                      ? Literal
-                                      : S extends z.core.$ZodDate
-                                        ? Date
-                                        : S extends z.core.$ZodEnum<infer Enum>
-                                          ? Enum[keyof Enum]
-                                          : S extends z.core.$ZodTemplateLiteral<
-                                                infer pattern
-                                              >
-                                            ? pattern
-                                            : S extends z.core.$ZodReadonly<
-                                                  infer Inner
-                                                >
-                                              ? InstanceOrPrimitiveOfSchema<Inner>
-                                              : S extends z.core.$ZodDefault<
-                                                    infer Default
-                                                  >
-                                                ? InstanceOrPrimitiveOfSchema<Default>
-                                                : S extends z.core.$ZodCatch<
-                                                      infer Catch
-                                                    >
-                                                  ? InstanceOrPrimitiveOfSchema<Catch>
-                                                  : never
-  : S extends CoValueClass
-    ? InstanceType<S> | null
-    : never;
+                  : S extends CoreCoOptionalSchema<infer T>
+                    ? InstanceOrPrimitiveOfSchemaCoValuesNullable<T> | undefined
+                    : S extends CoDiscriminatedUnionSchema<infer Members>
+                      ? InstanceOrPrimitiveOfSchemaCoValuesNullable<
+                          Members[number]
+                        >
+                      : never
+  : S extends z.core.$ZodType
+    ? S extends z.core.$ZodOptional<infer Inner extends z.core.$ZodType>
+      ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Inner> | undefined
+      : S extends z.ZodJSONSchema
+        ? JsonValue
+        : S extends z.core.$ZodUnion<
+              infer Members extends readonly z.core.$ZodType[]
+            >
+          ? InstanceOrPrimitiveOfSchemaCoValuesNullable<Members[number]>
+          : // primitives below here - we manually traverse to ensure we only allow what we can handle
+            S extends z.core.$ZodObject<infer Shape>
+            ? {
+                -readonly [key in keyof Shape]: InstanceOrPrimitiveOfSchema<
+                  Shape[key]
+                >;
+              }
+            : S extends z.core.$ZodArray<infer Item extends z.core.$ZodType>
+              ? InstanceOrPrimitiveOfSchema<Item>[]
+              : S extends z.core.$ZodTuple<
+                    infer Items extends z.core.$ZodType[]
+                  >
+                ? {
+                    [key in keyof Items]: InstanceOrPrimitiveOfSchema<
+                      Items[key]
+                    >;
+                  }
+                : S extends z.core.$ZodString
+                  ? string
+                  : S extends z.core.$ZodNumber
+                    ? number
+                    : S extends z.core.$ZodBoolean
+                      ? boolean
+                      : S extends z.core.$ZodLiteral<infer Literal>
+                        ? Literal
+                        : S extends z.core.$ZodDate
+                          ? Date
+                          : S extends z.core.$ZodEnum<infer Enum>
+                            ? Enum[keyof Enum]
+                            : S extends z.core.$ZodTemplateLiteral<
+                                  infer pattern
+                                >
+                              ? pattern
+                              : S extends z.core.$ZodReadonly<
+                                    infer Inner extends z.core.$ZodType
+                                  >
+                                ? InstanceOrPrimitiveOfSchema<Inner>
+                                : S extends z.core.$ZodDefault<
+                                      infer Default extends z.core.$ZodType
+                                    >
+                                  ? InstanceOrPrimitiveOfSchema<Default>
+                                  : S extends z.core.$ZodCatch<
+                                        infer Catch extends z.core.$ZodType
+                                      >
+                                    ? InstanceOrPrimitiveOfSchema<Catch>
+                                    : never
+    : S extends CoValueClass
+      ? InstanceType<S> | null
+      : never;

package/src/tools/implementation/zodSchema/unionUtils.ts

@@ -1,34 +1,34 @@
 import { RawAccount, RawCoList, RawCoMap } from "cojson";
-import { CoValueClass, CoValueFromRaw } from "../../internal.js";
 import {
+  AnyZodOrCoValueSchema,
+  CoDiscriminatedUnionSchema,
+  CoMap,
+  CoreCoDiscriminatedUnionSchema,
+  CoreCoMapSchema,
+  DiscriminableCoValueSchemas,
+  DiscriminableCoreCoValueSchema,
+} from "../../internal.js";
+import {
+  hydrateCoreCoValueSchema,
   isAnyCoValueSchema,
-  zodSchemaToCoSchema,
-} from "./runtimeConverters/zodSchemaToCoSchema.js";
-import { AccountSchema } from "./schemaTypes/AccountSchema.js";
-import { CoListSchema } from "./schemaTypes/CoListSchema.js";
-import { CoMapSchema } from "./schemaTypes/CoMapSchema.js";
+} from "./runtimeConverters/coValueSchemaTransformation.js";
 import { z } from "./zodReExport.js";
 
 export function schemaUnionDiscriminatorFor(
-  schema: z.core.$ZodDiscriminatedUnion,
+  schema: CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
 ) {
   if (isUnionOfCoMapsDeeply(schema)) {
-    if (!schema._zod.disc || schema._zod.disc.size == 0) {
-      throw new Error(
-        "z.union() of collaborative types is not supported, use co.discriminatedUnion() instead",
-      );
-    }
-
-    const discriminator = schema._zod.def.discriminator;
-    const field = schema._zod.disc.get(discriminator);
+    const definition = schema.getDefinition();
+    const { discriminatorMap, discriminator, options } = definition;
 
+    const field = discriminatorMap[discriminator];
     if (!field) {
       throw new Error(
         "co.discriminatedUnion() of collaborative types with non-existent discriminator key is not supported",
       );
     }
 
-    for (const value of field.values) {
+    for (const value of field) {
       if (typeof value !== "string" && typeof value !== "number") {
         throw new Error(
           "co.discriminatedUnion() of collaborative types with non-string or non-number discriminator value is not supported",
@@ -36,15 +36,17 @@ export function schemaUnionDiscriminatorFor(
       }
     }
 
-    const availableOptions: z.core.$ZodObject[] = [];
-
-    for (const option of schema._zod.def.options) {
-      if (option._zod.def.type === "object") {
-        availableOptions.push(option as z.core.$ZodObject);
-      } else if (option._zod.def.type === "union") {
-        for (const subOption of (option as z.core.$ZodUnion)._zod.def.options) {
-          if (subOption._zod.def.type === "object") {
-            availableOptions.push(subOption as z.core.$ZodObject);
+    const availableOptions: DiscriminableCoreCoValueSchema[] = [];
+
+    for (const option of options) {
+      if (option.builtin === "CoMap") {
+        availableOptions.push(option);
+      } else if (option.builtin === "CoDiscriminatedUnion") {
+        for (const subOption of (
+          option as CoDiscriminatedUnionSchema<any>
+        ).getDefinition().options) {
+          if (!options.includes(subOption)) {
+            options.push(subOption);
           }
         }
       } else {
@@ -64,10 +66,9 @@ export function schemaUnionDiscriminatorFor(
       for (const option of availableOptions) {
         let match = true;
 
-        for (const key of schema._zod.disc.keys()) {
-          const discriminatorDef = (option as z.core.$ZodObject)._zod.def.shape[
-            key as string
-          ];
+        for (const key of Object.keys(discriminatorMap)) {
+          const discriminatorDef = (option as CoreCoMapSchema).getDefinition()
+            .shape[key as string];
 
           const discriminatorValue = (_raw as RawCoMap).get(key as string);
 
@@ -88,7 +89,8 @@ export function schemaUnionDiscriminatorFor(
             break;
           }
 
-          const literalDef = discriminatorDef._zod.def as z.core.$ZodLiteralDef;
+          const literalDef = discriminatorDef._zod
+            .def as z.core.$ZodLiteralDef<any>;
 
           if (!Array.from(literalDef.values).includes(discriminatorValue)) {
             match = false;
@@ -97,12 +99,8 @@ export function schemaUnionDiscriminatorFor(
         }
 
         if (match) {
-          const coValueSchema = zodSchemaToCoSchema(option) as
-            | CoMapSchema<any>
-            | AccountSchema
-            | CoListSchema<any>;
-          return coValueSchema.getCoValueClass() as CoValueClass<any> &
-            CoValueFromRaw<any>;
+          const coValueSchema = hydrateCoreCoValueSchema(option as any);
+          return coValueSchema.getCoValueClass() as typeof CoMap;
         }
       }
 
@@ -114,34 +112,32 @@ export function schemaUnionDiscriminatorFor(
     return determineSchema;
   } else {
     throw new Error(
-      "z.discriminatedUnion() of non-collaborative types is not supported",
+      "co.discriminatedUnion() of non-collaborative types is not supported",
     );
   }
 }
 
-export function isUnionOfCoMapsDeeply(
-  schema: z.core.$ZodType,
-): schema is z.core.$ZodDiscriminatedUnion {
-  if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
-  } else {
-    return false;
-  }
+function isUnionOfCoMapsDeeply(
+  schema: CoreCoDiscriminatedUnionSchema<DiscriminableCoValueSchemas>,
+): boolean {
+  return schema.getDefinition().options.every(isCoMapOrUnionOfCoMapsDeeply);
 }
 
 function isCoMapOrUnionOfCoMapsDeeply(
-  schema: z.core.$ZodType,
-): schema is z.core.$ZodDiscriminatedUnion {
-  if (schema instanceof z.core.$ZodObject && isAnyCoValueSchema(schema)) {
+  schema: DiscriminableCoreCoValueSchema,
+): boolean {
+  if (schema.builtin === "CoMap") {
     return true;
-  } else if (schema instanceof z.core.$ZodUnion) {
-    return schema._zod.def.options.every(isCoMapOrUnionOfCoMapsDeeply);
+  } else if (schema.builtin === "CoDiscriminatedUnion") {
+    return (schema as CoDiscriminatedUnionSchema<any>)
+      .getDefinition()
+      .options.every(isCoMapOrUnionOfCoMapsDeeply);
   } else {
     return false;
   }
 }
 
-export function isUnionOfPrimitivesDeeply(schema: z.core.$ZodType) {
+export function isUnionOfPrimitivesDeeply(schema: AnyZodOrCoValueSchema) {
   if (schema instanceof z.core.$ZodUnion) {
     return schema._zod.def.options.every(isUnionOfPrimitivesDeeply);
   } else {