jazz-tools 0.15.16 → 0.16.1

package/dist/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.d.ts

@@ -1,12 +0,0 @@
-import { CoMap, CoValueClass } from "../../../internal.js";
-import { z } from "../zodReExport.js";
-import { AnyCoSchema, ZodPrimitiveSchema } from "../zodSchema.js";
-/**
- * Types of objects that can be nested inside CoValue schema containers
- */
-type SchemaField = AnyCoSchema | CoValueClass | ZodPrimitiveSchema | z.core.$ZodOptional<z.core.$ZodType> | z.core.$ZodUnion<z.core.$ZodType[]> | z.core.$ZodObject<z.core.$ZodLooseShape> | z.core.$ZodArray<z.core.$ZodType> | z.core.$ZodTuple<z.core.$ZodType[]> | z.core.$ZodReadonly<z.core.$ZodType> | z.core.$ZodLazy<z.core.$ZodType> | z.core.$ZodTemplateLiteral<any> | z.core.$ZodLiteral<any> | z.core.$ZodCatch<z.core.$ZodType> | z.core.$ZodEnum<any> | z.core.$ZodDefault<z.core.$ZodType> | z.core.$ZodCatch<z.core.$ZodType> | (z.core.$ZodCustom<any, any> & {
-    builtin: any;
-});
-export declare function schemaFieldToCoFieldDef(schema: SchemaField, isOptional?: boolean): string | number | boolean | Date | import("../../../internal.js").CoValue | CoMap | import("../../../internal.js").CoPlainText | import("../../../internal.js").BinaryCoStream | import("../../../internal.js").CoStream<unknown> | import("../../../internal.js").CoList<unknown> | null | undefined;
-export {};
-//# sourceMappingURL=zodFieldToCoFieldDef.d.ts.map

package/dist/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zodFieldToCoFieldDef.d.ts","sourceRoot":"","sources":["../../../../../src/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,YAAY,EAAkB,MAAM,sBAAsB,CAAC;AAQ3E,OAAO,EAKL,CAAC,EACF,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAMlE;;GAEG;AACH,KAAK,WAAW,GAEZ,WAAW,GAEX,YAAY,GACZ,kBAAkB,GAClB,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACpC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GACnC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,GACxC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACjC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,GACnC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACpC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAChC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,GAC/B,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,GACvB,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACjC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GACpB,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACnC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GACjC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG;IAAE,OAAO,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAErD,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,WAAW,EACnB,UAAU,UAAQ,ySA4HnB"}

package/dist/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.d.ts

@@ -1,9 +0,0 @@
-import { CoValueClass } from "../../../internal.js";
-import { z } from "../zodReExport.js";
-import { AnyCoSchema, CoValueClassFromAnySchema, CoValueOrZodSchema, CoValueSchemaFromZodSchema, ZodPrimitiveSchema } from "../zodSchema.js";
-export declare function isAnyCoValueSchema(schema: z.core.$ZodType | CoValueClass): schema is AnyCoSchema;
-export declare function isCoValueSchema(schema: z.core.$ZodType | CoValueClass): schema is CoValueSchemaFromZodSchema<AnyCoSchema>;
-export declare function zodSchemaToCoSchema<S extends z.core.$ZodType | AnyCoSchema>(schema: S): CoValueSchemaFromZodSchema<S>;
-export declare function anySchemaToCoSchema<S extends CoValueOrZodSchema>(schema: S): CoValueClassFromAnySchema<S>;
-export declare function zodSchemaToCoSchemaOrKeepPrimitive<S extends z.core.$ZodType>(schema: S): CoValueSchemaFromZodSchema<S> | ZodPrimitiveSchema;
-//# sourceMappingURL=zodSchemaToCoSchema.d.ts.map

package/dist/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"zodSchemaToCoSchema.d.ts","sourceRoot":"","sources":["../../../../../src/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAOL,YAAY,EAWb,MAAM,sBAAsB,CAAC;AAQ9B,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AACtC,OAAO,EACL,WAAW,EACX,yBAAyB,EACzB,kBAAkB,EAClB,0BAA0B,EAC1B,kBAAkB,EAKnB,MAAM,iBAAiB,CAAC;AAKzB,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,YAAY,GACrC,MAAM,IAAI,WAAW,CAEvB;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,YAAY,GACrC,MAAM,IAAI,0BAA0B,CAAC,WAAW,CAAC,CAEnD;AAyHD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,QAAQ,GAAG,WAAW,EACzE,MAAM,EAAE,CAAC,GACR,0BAA0B,CAAC,CAAC,CAAC,CAQ/B;AAGD,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,kBAAkB,EAC9D,MAAM,EAAE,CAAC,GACR,yBAAyB,CAAC,CAAC,CAAC,CAkB9B;AAED,wBAAgB,kCAAkC,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,QAAQ,EAC1E,MAAM,EAAE,CAAC,GACR,0BAA0B,CAAC,CAAC,CAAC,GAAG,kBAAkB,CAMpD"}

package/src/tools/implementation/zodSchema/runtimeConverters/zodFieldToCoFieldDef.ts

@@ -1,172 +0,0 @@
-import { CoMap, CoValueClass, isCoValueClass } from "../../../internal.js";
-import { coField } from "../../schema.js";
-import { isAnyCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
-import {
-  isUnionOfCoMapsDeeply,
-  isUnionOfPrimitivesDeeply,
-  schemaUnionDiscriminatorFor,
-} from "../unionUtils.js";
-import {
-  ZodCatch,
-  ZodDefault,
-  ZodLazy,
-  ZodReadonly,
-  z,
-} from "../zodReExport.js";
-import { AnyCoSchema, ZodPrimitiveSchema } from "../zodSchema.js";
-import {
-  isCoValueSchema,
-  zodSchemaToCoSchemaOrKeepPrimitive,
-} from "./zodSchemaToCoSchema.js";
-
-/**
- * Types of objects that can be nested inside CoValue schema containers
- */
-type SchemaField =
-  // Schemas created with co.map(), co.record(), co.list(), etc.
-  | AnyCoSchema
-  // CoValue classes created with class syntax, or framework-provided classes like Group
-  | CoValueClass
-  | ZodPrimitiveSchema
-  | z.core.$ZodOptional<z.core.$ZodType>
-  | z.core.$ZodUnion<z.core.$ZodType[]>
-  | z.core.$ZodObject<z.core.$ZodLooseShape>
-  | z.core.$ZodArray<z.core.$ZodType>
-  | z.core.$ZodTuple<z.core.$ZodType[]>
-  | z.core.$ZodReadonly<z.core.$ZodType>
-  | z.core.$ZodLazy<z.core.$ZodType>
-  | z.core.$ZodTemplateLiteral<any>
-  | z.core.$ZodLiteral<any>
-  | z.core.$ZodCatch<z.core.$ZodType>
-  | z.core.$ZodEnum<any>
-  | z.core.$ZodDefault<z.core.$ZodType>
-  | z.core.$ZodCatch<z.core.$ZodType>
-  | (z.core.$ZodCustom<any, any> & { builtin: any });
-
-export function schemaFieldToCoFieldDef(
-  schema: SchemaField,
-  isOptional = false,
-) {
-  if (isCoValueClass(schema)) {
-    if (isOptional) {
-      return coField.ref(schema, { optional: true });
-    } else {
-      return coField.ref(schema);
-    }
-  } else if (isCoValueSchema(schema)) {
-    if (isAnyCoOptionalSchema(schema)) {
-      return coField.ref(schema.getCoValueClass(), {
-        optional: true,
-      });
-    }
-
-    if (isOptional) {
-      return coField.ref(schema.getCoValueClass(), { optional: true });
-    } else {
-      return coField.ref(schema.getCoValueClass());
-    }
-  } else {
-    if ("_zod" in schema) {
-      if (schema._zod.def.type === "optional") {
-        const inner = zodSchemaToCoSchemaOrKeepPrimitive(
-          schema._zod.def.innerType,
-        );
-        return schemaFieldToCoFieldDef(inner, true);
-      } else if (schema._zod.def.type === "string") {
-        return coField.string;
-      } else if (schema._zod.def.type === "number") {
-        return coField.number;
-      } else if (schema._zod.def.type === "boolean") {
-        return coField.boolean;
-      } else if (schema._zod.def.type === "null") {
-        return coField.null;
-      } else if (schema._zod.def.type === "enum") {
-        return coField.string;
-      } else if (schema._zod.def.type === "readonly") {
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodReadonly).def.innerType as SchemaField,
-          isOptional,
-        );
-      } else if (schema._zod.def.type === "date") {
-        return coField.optional.Date;
-      } else if (schema._zod.def.type === "template_literal") {
-        return coField.string;
-      } else if (schema._zod.def.type === "lazy") {
-        // Mostly to support z.json()
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodLazy).unwrap() as SchemaField,
-          isOptional,
-        );
-      } else if (
-        schema._zod.def.type === "default" ||
-        schema._zod.def.type === "catch"
-      ) {
-        console.warn(
-          "z.default()/z.catch() are not supported in collaborative schemas. They will be ignored.",
-        );
-
-        return schemaFieldToCoFieldDef(
-          (schema as unknown as ZodDefault | ZodCatch).def
-            .innerType as SchemaField,
-          isOptional,
-        );
-      } else if (schema._zod.def.type === "literal") {
-        if (
-          schema._zod.def.values.some(
-            (literal) => typeof literal === "undefined",
-          )
-        ) {
-          throw new Error("z.literal() with undefined is not supported");
-        }
-        if (schema._zod.def.values.some((literal) => literal === null)) {
-          throw new Error("z.literal() with null is not supported");
-        }
-        if (
-          schema._zod.def.values.some((literal) => typeof literal === "bigint")
-        ) {
-          throw new Error("z.literal() with bigint is not supported");
-        }
-        return coField.literal(
-          ...(schema._zod.def.values as Exclude<
-            (typeof schema._zod.def.values)[number],
-            undefined | null | bigint
-          >[]),
-        );
-      } else if (
-        schema._zod.def.type === "object" ||
-        schema._zod.def.type === "array" ||
-        schema._zod.def.type === "tuple"
-      ) {
-        return coField.json();
-      } else if (schema._zod.def.type === "custom") {
-        if ("builtin" in schema) {
-          return schemaFieldToCoFieldDef(schema.builtin, isOptional);
-        } else {
-          throw new Error(`Unsupported custom zod type`);
-        }
-      } else if (schema._zod.def.type === "union") {
-        if (isUnionOfPrimitivesDeeply(schema)) {
-          return coField.json();
-        } else if (isUnionOfCoMapsDeeply(schema)) {
-          const result = schemaUnionDiscriminatorFor(schema);
-
-          if (isOptional) {
-            return coField.ref<CoValueClass<CoMap>>(result, { optional: true });
-          } else {
-            return coField.ref<CoValueClass<CoMap>>(result);
-          }
-        } else {
-          throw new Error(
-            "z.union()/z.discriminatedUnion() of mixed collaborative and non-collaborative types is not supported",
-          );
-        }
-      } else {
-        throw new Error(
-          `Unsupported zod type: ${(schema._zod?.def as any)?.type || JSON.stringify(schema)}`,
-        );
-      }
-    } else {
-      throw new Error(`Unsupported zod type: ${schema}`);
-    }
-  }
-}

package/src/tools/implementation/zodSchema/runtimeConverters/zodSchemaToCoSchema.ts

@@ -1,218 +0,0 @@
-import { RawCoList, RawCoMap } from "cojson";
-import {
-  Account,
-  CoFeed,
-  CoList,
-  CoMap,
-  CoPlainText,
-  CoRichText,
-  CoValueClass,
-  FileStream,
-  SchemaUnion,
-  enrichAccountSchema,
-  enrichCoDiscriminatedUnionSchema,
-  enrichCoFeedSchema,
-  enrichCoListSchema,
-  enrichCoMapSchema,
-  enrichFileStreamSchema,
-  enrichPlainTextSchema,
-  isCoValueClass,
-} from "../../../internal.js";
-import { coField } from "../../schema.js";
-import { isAnyCoOptionalSchema } from "../schemaTypes/CoOptionalSchema.js";
-import { enrichRichTextSchema } from "../schemaTypes/RichTextSchema.js";
-import {
-  isUnionOfCoMapsDeeply,
-  schemaUnionDiscriminatorFor,
-} from "../unionUtils.js";
-import { z } from "../zodReExport.js";
-import {
-  AnyCoSchema,
-  CoValueClassFromAnySchema,
-  CoValueOrZodSchema,
-  CoValueSchemaFromZodSchema,
-  ZodPrimitiveSchema,
-  getDef,
-  isZodArray,
-  isZodCustom,
-  isZodObject,
-} from "../zodSchema.js";
-import { schemaFieldToCoFieldDef } from "./zodFieldToCoFieldDef.js";
-
-let coSchemasForZodSchemas = new Map<z.core.$ZodType, AnyCoSchema>();
-
-export function isAnyCoValueSchema(
-  schema: z.core.$ZodType | CoValueClass,
-): schema is AnyCoSchema {
-  return "collaborative" in schema && schema.collaborative === true;
-}
-
-export function isCoValueSchema(
-  schema: z.core.$ZodType | CoValueClass,
-): schema is CoValueSchemaFromZodSchema<AnyCoSchema> {
-  return isAnyCoValueSchema(schema) && "getCoValueClass" in schema;
-}
-
-/**
- * Convert a Zod schema into a CoValue schema.
- *
- * @param schema A Zod schema that may represent a CoValue schema
- * @returns The CoValue schema matching the provided ProtoCoSchema, or `null` if the Zod schema
- * does not match a CoValue schema.
- */
-function tryZodSchemaToCoSchema<S extends z.core.$ZodType>(
-  schema: S,
-): CoValueSchemaFromZodSchema<S> | null {
-  if (isAnyCoValueSchema(schema)) {
-    if (coSchemasForZodSchemas.has(schema)) {
-      return coSchemasForZodSchemas.get(
-        schema,
-      ) as CoValueSchemaFromZodSchema<S>;
-    }
-
-    if (isAnyCoOptionalSchema(schema)) {
-      // Optional schemas are not supported as top-level schemas
-      return null;
-    } else if (isZodObject(schema)) {
-      const def = getDef(schema);
-
-      const ClassToExtend =
-        "builtin" in schema && schema.builtin === "Account" ? Account : CoMap;
-
-      const coValueClass = class ZCoMap extends ClassToExtend {
-        constructor(options: { fromRaw: RawCoMap } | undefined) {
-          super(options);
-          for (const [field, fieldType] of Object.entries(
-            def.shape as z.core.$ZodShape,
-          )) {
-            (this as any)[field] = schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(fieldType),
-            );
-          }
-          if (def.catchall) {
-            (this as any)[coField.items] = schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(def.catchall),
-            );
-          }
-        }
-      };
-
-      const coValueSchema =
-        ClassToExtend === Account
-          ? enrichAccountSchema(schema as any, coValueClass as any)
-          : enrichCoMapSchema(schema as any, coValueClass as any);
-
-      coSchemasForZodSchemas.set(schema, coValueSchema);
-      return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-    } else if (isZodArray(schema)) {
-      const def = getDef(schema);
-      const coValueClass = class ZCoList extends CoList {
-        constructor(options: { fromRaw: RawCoList } | undefined) {
-          super(options);
-          (this as any)[coField.items] = schemaFieldToCoFieldDef(
-            zodSchemaToCoSchemaOrKeepPrimitive(def.element),
-          );
-        }
-      };
-
-      const coValueSchema = enrichCoListSchema(schema, coValueClass as any);
-
-      coSchemasForZodSchemas.set(schema, coValueSchema);
-      return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-    } else if (isZodCustom(schema)) {
-      if ("builtin" in schema) {
-        if (schema.builtin === "CoFeed" && "element" in schema) {
-          const coValueClass = CoFeed.Of(
-            schemaFieldToCoFieldDef(
-              zodSchemaToCoSchemaOrKeepPrimitive(
-                schema.element as z.core.$ZodType,
-              ),
-            ),
-          );
-          const coValueSchema = enrichCoFeedSchema(schema, coValueClass as any);
-          return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-        } else if (schema.builtin === "FileStream") {
-          const coValueClass = FileStream;
-          const coValueSchema = enrichFileStreamSchema(schema, coValueClass);
-          return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-        } else if (schema.builtin === "CoPlainText") {
-          const coValueClass = CoPlainText;
-          const coValueSchema = enrichPlainTextSchema(schema, coValueClass);
-          return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-        } else if (schema.builtin === "CoRichText") {
-          const coValueClass = CoRichText;
-          const coValueSchema = enrichRichTextSchema(schema, coValueClass);
-          return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-        } else {
-          throw new Error(`Unsupported builtin type: ${schema.builtin}`);
-        }
-      } else {
-        throw new Error(`Unsupported custom zod type`);
-      }
-    } else {
-      throw new Error(
-        `Unsupported zod CoValue type for top-level schema: ${schema._zod?.def?.type || JSON.stringify(schema, undefined, 2)}`,
-      );
-    }
-  } else if (schema instanceof z.core.$ZodDiscriminatedUnion) {
-    if (isUnionOfCoMapsDeeply(schema)) {
-      const coValueClass = SchemaUnion.Of(schemaUnionDiscriminatorFor(schema));
-      const coValueSchema = enrichCoDiscriminatedUnionSchema(
-        schema as any,
-        coValueClass as any,
-      );
-      return coValueSchema as unknown as CoValueSchemaFromZodSchema<S>;
-    } else {
-      throw new Error(
-        "z.discriminatedUnion() of non-collaborative types is not supported as a top-level schema",
-      );
-    }
-  } else {
-    return null;
-  }
-}
-
-export function zodSchemaToCoSchema<S extends z.core.$ZodType | AnyCoSchema>(
-  schema: S,
-): CoValueSchemaFromZodSchema<S> {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
-    throw new Error(
-      `Unsupported zod type: ${schema._zod?.def?.type || JSON.stringify(schema)}`,
-    );
-  }
-  return coSchema;
-}
-
-// TODO this should be coValueClassOrAnySchemaToCoValueClass
-export function anySchemaToCoSchema<S extends CoValueOrZodSchema>(
-  schema: S,
-): CoValueClassFromAnySchema<S> {
-  if (isCoValueClass(schema)) {
-    return schema as any;
-  } else if (isCoValueSchema(schema)) {
-    return schema.getCoValueClass() as any;
-  } else if ("def" in schema) {
-    const coSchema = tryZodSchemaToCoSchema(
-      schema as z.core.$ZodType | AnyCoSchema,
-    );
-    if (!coSchema) {
-      throw new Error(
-        `Unsupported zod type: ${(schema.def as any)?.type || JSON.stringify(schema)}`,
-      );
-    }
-    return coSchema.getCoValueClass() as any;
-  }
-
-  throw new Error(`Unsupported schema: ${JSON.stringify(schema)}`);
-}
-
-export function zodSchemaToCoSchemaOrKeepPrimitive<S extends z.core.$ZodType>(
-  schema: S,
-): CoValueSchemaFromZodSchema<S> | ZodPrimitiveSchema {
-  const coSchema = tryZodSchemaToCoSchema(schema);
-  if (!coSchema) {
-    return schema as any;
-  }
-  return coSchema;
-}