@prismicio/types-internal 4.0.0-pr.6.eb53f11 → 4.0.0

package/dist/content/document.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"document.d.ts","names":[],"sources":["../../src/content/document.ts"],"mappings":";;;;cAKa,qBAAA,EAAqB,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA,aAAA,UAAA,CAAA,CAAA,YAAA,WAAA,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}
+{"version":3,"file":"document.d.ts","names":[],"sources":["../../src/content/document.ts"],"mappings":";;;;cAKa,qBAAA,EAAqB,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA,aAAA,UAAA,CAAA,CAAA,WAAA,CAAA,aAAA,WAAA,CAAA,CAAA,IAAA,CAAA,iBAAA,CAAA,aAAA;AAAA,KAEtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA"}

package/dist/content/field.d.ts

@@ -36,35 +36,6 @@ declare const SelectContentSchema: z.ZodMiniObject<{
   value: z.ZodMiniString<string>;
   __TYPE__: z.ZodMiniLiteral<"FieldContent">;
 }, z.core.$strip>;
-declare const FieldContentSchema: z.ZodMiniUnion<readonly [z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Text">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Color">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Date">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Timestamp">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Number">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Range">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>, z.ZodMiniObject<{
-  type: z.ZodMiniLiteral<"Select">;
-  value: z.ZodMiniString<string>;
-  __TYPE__: z.ZodMiniLiteral<"FieldContent">;
-}, z.core.$strip>]>;
 type TextContent = z.infer<typeof TextContentSchema>;
 type ColorContent = z.infer<typeof ColorContentSchema>;
 type DateContent = z.infer<typeof DateContentSchema>;
@@ -72,7 +43,7 @@ type TimestampContent = z.infer<typeof TimestampContentSchema>;
 type NumberContent = z.infer<typeof NumberContentSchema>;
 type RangeContent = z.infer<typeof RangeContentSchema>;
 type SelectContent = z.infer<typeof SelectContentSchema>;
-type FieldContent = z.infer<typeof FieldContentSchema>;
+type FieldContent = TextContent | ColorContent | DateContent | TimestampContent | NumberContent | RangeContent | SelectContent;
 //#endregion
 export { ColorContent, DateContent, FieldContent, NumberContent, RangeContent, SelectContent, TextContent, TimestampContent };
 //# sourceMappingURL=field.d.ts.map

package/dist/content/field.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"field.d.ts","names":[],"sources":["../../src/content/field.ts"],"mappings":";;;cAQa,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;cAOtB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;cAOnB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;cAOnB,kBAAA,EAAkB,CAAA,CAAA,YAAA,WAAA,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAUnB,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAClC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}
+{"version":3,"file":"field.d.ts","names":[],"sources":["../../src/content/field.ts"],"mappings":";;;cAQa,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,iBAAA,EAAiB,CAAA,CAAA,aAAA;;;;;cAOjB,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;cAOtB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;cAOnB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;;cAOlB,mBAAA,EAAmB,CAAA,CAAA,aAAA;;;;;KAiBpB,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,WAAA,GAAc,CAAA,CAAE,KAAA,QAAa,iBAAA;AAAA,KAC7B,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAClC,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAC9B,aAAA,GAAgB,CAAA,CAAE,KAAA,QAAa,mBAAA;AAAA,KAC/B,YAAA,GACT,WAAA,GACA,YAAA,GACA,WAAA,GACA,gBAAA,GACA,aAAA,GACA,YAAA,GACA,aAAA"}

package/dist/content/field.js.map

@@ -1 +1 @@
-{"version":3,"file":"field.js","names":[],"sources":["../../src/content/field.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { SelectModel } from \"../model/select\"\n\nexport const FieldContentType = \"FieldContent\" as const\nexport const SelectFieldType = \"Select\" as const\n\n// Text\nexport const TextContentSchema = z.object({\n\ttype: z.literal(\"Text\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Color\nexport const ColorContentSchema = z.object({\n\ttype: z.literal(\"Color\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Date\nexport const DateContentSchema = z.object({\n\ttype: z.literal(\"Date\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Timestamp\nexport const TimestampContentSchema = z.object({\n\ttype: z.literal(\"Timestamp\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Number\nexport const NumberContentSchema = z.object({\n\ttype: z.literal(\"Number\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Range\nexport const RangeContentSchema = z.object({\n\ttype: z.literal(\"Range\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Select\nexport const SelectContentSchema = z.object({\n\ttype: z.literal(SelectFieldType),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Fields\nexport const FieldContentSchema = z.union([\n\tTextContentSchema,\n\tColorContentSchema,\n\tDateContentSchema,\n\tTimestampContentSchema,\n\tNumberContentSchema,\n\tRangeContentSchema,\n\tSelectContentSchema,\n])\n\nexport type TextContent = z.infer<typeof TextContentSchema>\nexport type ColorContent = z.infer<typeof ColorContentSchema>\nexport type DateContent = z.infer<typeof DateContentSchema>\nexport type TimestampContent = z.infer<typeof TimestampContentSchema>\nexport type NumberContent = z.infer<typeof NumberContentSchema>\nexport type RangeContent = z.infer<typeof RangeContentSchema>\nexport type SelectContent = z.infer<typeof SelectContentSchema>\nexport type FieldContent = z.infer<typeof FieldContentSchema>\n\n/**\n * Returns the default value for a Select field based on its configuration.\n */\nexport const SelectContentDefaultValue = (field: SelectModel): SelectContent | undefined =>\n\tfield.config?.default_value\n\t\t? {\n\t\t\t\t__TYPE__: FieldContentType,\n\t\t\t\ttype: SelectFieldType,\n\t\t\t\tvalue: field.config.default_value || \"\",\n\t\t\t}\n\t\t: undefined\n"],"mappings":";;AAIA,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAG/B,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,yBAAyB,EAAE,OAAO;CAC9C,MAAM,EAAE,QAAQ,YAAY;CAC5B,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,SAAS;CACzB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,gBAAgB;CAChC,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,MAAM;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC"}
+{"version":3,"file":"field.js","names":[],"sources":["../../src/content/field.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { SelectModel } from \"../model/select\"\n\nexport const FieldContentType = \"FieldContent\" as const\nexport const SelectFieldType = \"Select\" as const\n\n// Text\nexport const TextContentSchema = z.object({\n\ttype: z.literal(\"Text\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Color\nexport const ColorContentSchema = z.object({\n\ttype: z.literal(\"Color\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Date\nexport const DateContentSchema = z.object({\n\ttype: z.literal(\"Date\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Timestamp\nexport const TimestampContentSchema = z.object({\n\ttype: z.literal(\"Timestamp\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Number\nexport const NumberContentSchema = z.object({\n\ttype: z.literal(\"Number\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Range\nexport const RangeContentSchema = z.object({\n\ttype: z.literal(\"Range\"),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Select\nexport const SelectContentSchema = z.object({\n\ttype: z.literal(SelectFieldType),\n\tvalue: z.string().check(z.trim()),\n\t__TYPE__: z.literal(FieldContentType),\n})\n\n// Fields\nexport const FieldContentSchema: z.ZodMiniType<FieldContent> = z.union([\n\tTextContentSchema,\n\tColorContentSchema,\n\tDateContentSchema,\n\tTimestampContentSchema,\n\tNumberContentSchema,\n\tRangeContentSchema,\n\tSelectContentSchema,\n])\n\nexport type TextContent = z.infer<typeof TextContentSchema>\nexport type ColorContent = z.infer<typeof ColorContentSchema>\nexport type DateContent = z.infer<typeof DateContentSchema>\nexport type TimestampContent = z.infer<typeof TimestampContentSchema>\nexport type NumberContent = z.infer<typeof NumberContentSchema>\nexport type RangeContent = z.infer<typeof RangeContentSchema>\nexport type SelectContent = z.infer<typeof SelectContentSchema>\nexport type FieldContent =\n\t| TextContent\n\t| ColorContent\n\t| DateContent\n\t| TimestampContent\n\t| NumberContent\n\t| RangeContent\n\t| SelectContent\n\n/**\n * Returns the default value for a Select field based on its configuration.\n */\nexport const SelectContentDefaultValue = (field: SelectModel): SelectContent | undefined =>\n\tfield.config?.default_value\n\t\t? {\n\t\t\t\t__TYPE__: FieldContentType,\n\t\t\t\ttype: SelectFieldType,\n\t\t\t\tvalue: field.config.default_value || \"\",\n\t\t\t}\n\t\t: undefined\n"],"mappings":";;AAIA,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAG/B,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,oBAAoB,EAAE,OAAO;CACzC,MAAM,EAAE,QAAQ,OAAO;CACvB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,yBAAyB,EAAE,OAAO;CAC9C,MAAM,EAAE,QAAQ,YAAY;CAC5B,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,SAAS;CACzB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAqB,EAAE,OAAO;CAC1C,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,sBAAsB,EAAE,OAAO;CAC3C,MAAM,EAAE,QAAQ,gBAAgB;CAChC,OAAO,EAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACjC,UAAU,EAAE,QAAQ,iBAAiB;CACrC,CAAC;AAGF,MAAa,qBAAkD,EAAE,MAAM;CACtE;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC"}

package/dist/content/group.d.ts

@@ -13,6 +13,7 @@ declare const GroupContentSchema: z.ZodMiniObject<{
   value: z.ZodMiniArray<z.ZodMiniType<GroupItemContent, unknown, z.core.$ZodTypeInternals<GroupItemContent, unknown>>>;
 }, z.core.$strip>;
 type GroupContent = z.infer<typeof GroupContentSchema>;
+type NestableAndGroupContent = NestableContent | GroupContent;
 //#endregion
-export { GroupContent, GroupItemContent };
+export { GroupContent, GroupItemContent, NestableAndGroupContent };
 //# sourceMappingURL=group.d.ts.map

package/dist/content/group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group.d.ts","names":[],"sources":["../../src/content/group.ts"],"mappings":";;;;cAOa,oBAAA;AAAA,KAkBD,gBAAA;EACX,QAAA,SAAiB,oBAAA;EACjB,GAAA;EACA,KAAA,WAAgB,eAAA,GAAkB,YAAA;AAAA;AAAA,cAMtB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA"}
+{"version":3,"file":"group.d.ts","names":[],"sources":["../../src/content/group.ts"],"mappings":";;;;cAOa,oBAAA;AAAA,KAkBD,gBAAA;EACX,QAAA,SAAiB,oBAAA;EACjB,GAAA;EACA,KAAA,WAAgB,eAAA,GAAkB,YAAA;AAAA;AAAA,cAMtB,kBAAA,EAAkB,CAAA,CAAA,aAAA;;;;KAKnB,YAAA,GAAe,CAAA,CAAE,KAAA,QAAa,kBAAA;AAAA,KAO9B,uBAAA,GAA0B,eAAA,GAAkB,YAAA"}

package/dist/content/group.js.map

@@ -1 +1 @@
-{"version":3,"file":"group.js","names":[],"sources":["../../src/content/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { GroupModel } from \"../model/group\"\nimport { NestableContentDefaultValue, NestableContentSchema } from \"./nestable\"\nimport type { NestableContent } from \"./nestable\"\n\n// Item\nexport const GroupItemContentType = \"GroupItemContent\" as const\n\nexport const GroupItemContentSchema: z.ZodMiniType<GroupItemContent> = z.object({\n\t__TYPE__: z.literal(GroupItemContentType),\n\tkey: z.string(),\n\tvalue: z.array(\n\t\tz.tuple([\n\t\t\tz.string(),\n\t\t\tz.union([\n\t\t\t\tNestableContentSchema,\n\t\t\t\t// `lazy` is used to handle circular dependency on GroupContentSchema\n\t\t\t\tz.lazy(() => GroupContentSchema),\n\t\t\t]),\n\t\t]),\n\t),\n})\n\n// Manual type definition to handle circular dependency on GroupItemContentSchema\nexport type GroupItemContent = {\n\t__TYPE__: typeof GroupItemContentType\n\tkey: string\n\tvalue: [string, NestableContent | GroupContent][]\n}\n\n// Group\nexport const GroupContentType = \"GroupContentType\" as const\n\nexport const GroupContentSchema = z.object({\n\t__TYPE__: z.literal(GroupContentType),\n\tvalue: z.array(GroupItemContentSchema),\n})\n\nexport type GroupContent = z.infer<typeof GroupContentSchema>\n\nexport const NestableAndGroupContentSchema = z.union([NestableContentSchema, GroupContentSchema])\n\nexport type NestableAndGroupContent = z.infer<typeof NestableAndGroupContentSchema>\n\n// Default values for GroupContent\nexport function groupContentWithDefaultValues(\n\tcustomType: GroupModel,\n\tcontent: GroupContent,\n): GroupContent {\n\tconst fields = customType.config?.fields\n\tif (!fields) return content\n\n\treturn {\n\t\t...content,\n\t\tvalue: content.value.map((groupItem) => {\n\t\t\tconst updatedValue = Object.entries(fields).reduce<GroupItemContent[\"value\"]>(\n\t\t\t\t(acc, [fieldKey, fieldDef]) => {\n\t\t\t\t\tconst existingField = groupItem.value.find(([key]) => key === fieldKey)\n\n\t\t\t\t\tif (existingField) {\n\t\t\t\t\t\treturn [...acc, existingField]\n\t\t\t\t\t}\n\n\t\t\t\t\t// Field is missing, check if we can add a default value\n\t\t\t\t\tif (fieldDef.type === \"Group\") {\n\t\t\t\t\t\t// Recursively apply defaults to nested groups\n\t\t\t\t\t\treturn [\n\t\t\t\t\t\t\t...acc,\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\tfieldKey,\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t__TYPE__: GroupContentType,\n\t\t\t\t\t\t\t\t\tvalue: [],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t]\n\t\t\t\t\t}\n\n\t\t\t\t\tconst defaultValue = NestableContentDefaultValue(fieldDef)\n\t\t\t\t\tif (defaultValue) {\n\t\t\t\t\t\treturn [...acc, [fieldKey, defaultValue]]\n\t\t\t\t\t}\n\n\t\t\t\t\treturn acc\n\t\t\t\t},\n\t\t\t\t[],\n\t\t\t)\n\n\t\t\treturn {\n\t\t\t\t...groupItem,\n\t\t\t\tvalue: updatedValue,\n\t\t\t}\n\t\t}),\n\t}\n}\n"],"mappings":";;;AAOA,MAAa,uBAAuB;AAEpC,MAAa,yBAA0D,EAAE,OAAO;CAC/E,UAAU,EAAE,QAAQ,qBAAqB;CACzC,KAAK,EAAE,QAAQ;CACf,OAAO,EAAE,MACR,EAAE,MAAM,CACP,EAAE,QAAQ,EACV,EAAE,MAAM,CACP,uBAEA,EAAE,WAAW,mBAAmB,CAChC,CAAC,CACF,CAAC,CACF;CACD,CAAC;AAUF,MAAa,mBAAmB;AAEhC,MAAa,qBAAqB,EAAE,OAAO;CAC1C,UAAU,EAAE,QAAQ,iBAAiB;CACrC,OAAO,EAAE,MAAM,uBAAuB;CACtC,CAAC;AAIF,MAAa,gCAAgC,EAAE,MAAM,CAAC,uBAAuB,mBAAmB,CAAC"}
+{"version":3,"file":"group.js","names":[],"sources":["../../src/content/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { GroupModel } from \"../model/group\"\nimport { NestableContentDefaultValue, NestableContentSchema } from \"./nestable\"\nimport type { NestableContent } from \"./nestable\"\n\n// Item\nexport const GroupItemContentType = \"GroupItemContent\" as const\n\nexport const GroupItemContentSchema: z.ZodMiniType<GroupItemContent> = z.object({\n\t__TYPE__: z.literal(GroupItemContentType),\n\tkey: z.string(),\n\tvalue: z.array(\n\t\tz.tuple([\n\t\t\tz.string(),\n\t\t\tz.union([\n\t\t\t\tNestableContentSchema,\n\t\t\t\t// `lazy` is used to handle circular dependency on GroupContentSchema\n\t\t\t\tz.lazy(() => GroupContentSchema),\n\t\t\t]),\n\t\t]),\n\t),\n})\n\n// Manual type definition to handle circular dependency on GroupItemContentSchema\nexport type GroupItemContent = {\n\t__TYPE__: typeof GroupItemContentType\n\tkey: string\n\tvalue: [string, NestableContent | GroupContent][]\n}\n\n// Group\nexport const GroupContentType = \"GroupContentType\" as const\n\nexport const GroupContentSchema = z.object({\n\t__TYPE__: z.literal(GroupContentType),\n\tvalue: z.array(GroupItemContentSchema),\n})\n\nexport type GroupContent = z.infer<typeof GroupContentSchema>\n\nexport const NestableAndGroupContentSchema: z.ZodMiniType<NestableAndGroupContent> = z.union([\n\tNestableContentSchema,\n\tGroupContentSchema,\n])\n\nexport type NestableAndGroupContent = NestableContent | GroupContent\n\n// Default values for GroupContent\nexport function groupContentWithDefaultValues(\n\tcustomType: GroupModel,\n\tcontent: GroupContent,\n): GroupContent {\n\tconst fields = customType.config?.fields\n\tif (!fields) return content\n\n\treturn {\n\t\t...content,\n\t\tvalue: content.value.map((groupItem) => {\n\t\t\tconst updatedValue = Object.entries(fields).reduce<GroupItemContent[\"value\"]>(\n\t\t\t\t(acc, [fieldKey, fieldDef]) => {\n\t\t\t\t\tconst existingField = groupItem.value.find(([key]) => key === fieldKey)\n\n\t\t\t\t\tif (existingField) {\n\t\t\t\t\t\treturn [...acc, existingField]\n\t\t\t\t\t}\n\n\t\t\t\t\t// Field is missing, check if we can add a default value\n\t\t\t\t\tif (fieldDef.type === \"Group\") {\n\t\t\t\t\t\t// Recursively apply defaults to nested groups\n\t\t\t\t\t\treturn [\n\t\t\t\t\t\t\t...acc,\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\tfieldKey,\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t__TYPE__: GroupContentType,\n\t\t\t\t\t\t\t\t\tvalue: [],\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t],\n\t\t\t\t\t\t]\n\t\t\t\t\t}\n\n\t\t\t\t\tconst defaultValue = NestableContentDefaultValue(fieldDef)\n\t\t\t\t\tif (defaultValue) {\n\t\t\t\t\t\treturn [...acc, [fieldKey, defaultValue]]\n\t\t\t\t\t}\n\n\t\t\t\t\treturn acc\n\t\t\t\t},\n\t\t\t\t[],\n\t\t\t)\n\n\t\t\treturn {\n\t\t\t\t...groupItem,\n\t\t\t\tvalue: updatedValue,\n\t\t\t}\n\t\t}),\n\t}\n}\n"],"mappings":";;;AAOA,MAAa,uBAAuB;AAEpC,MAAa,yBAA0D,EAAE,OAAO;CAC/E,UAAU,EAAE,QAAQ,qBAAqB;CACzC,KAAK,EAAE,QAAQ;CACf,OAAO,EAAE,MACR,EAAE,MAAM,CACP,EAAE,QAAQ,EACV,EAAE,MAAM,CACP,uBAEA,EAAE,WAAW,mBAAmB,CAChC,CAAC,CACF,CAAC,CACF;CACD,CAAC;AAUF,MAAa,mBAAmB;AAEhC,MAAa,qBAAqB,EAAE,OAAO;CAC1C,UAAU,EAAE,QAAQ,iBAAiB;CACrC,OAAO,EAAE,MAAM,uBAAuB;CACtC,CAAC;AAIF,MAAa,gCAAwE,EAAE,MAAM,CAC5F,uBACA,mBACA,CAAC"}

package/dist/content/legacy/group.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod/mini";
+
+//#region src/content/legacy/group.d.ts
+declare const GroupItemLegacySchema: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniUnknown>;
+type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>;
+type GroupLegacy = (GroupItemLegacy | null)[];
+//#endregion
+export { GroupLegacy };
+//# sourceMappingURL=group.d.ts.map

package/dist/content/legacy/group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"group.d.ts","names":[],"sources":["../../../src/content/legacy/group.ts"],"mappings":";;;cAOa,qBAAA,EAAqB,CAAA,CAAA,aAAA,CAAA,CAAA,CAAA,aAAA,UAAA,CAAA,CAAA,cAAA;AAAA,KAEtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,KAMjC,WAAA,IAAe,eAAA"}

package/dist/content/legacy/group.js.map

@@ -1 +1 @@
-{"version":3,"file":"group.js","names":[],"sources":["../../../src/content/legacy/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { NestableLegacySchema } from \"./nestable\"\n\nexport const GroupItemLegacySchema = z.record(z.string(), z.unknown())\n\nexport type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>\n\nexport const GroupLegacySchema = z.array(z.union([GroupItemLegacySchema, z.null()]))\n\nexport type GroupLegacy = z.infer<typeof GroupLegacySchema>\n\nexport const NestableAndGroupLegacySchema = z.union([NestableLegacySchema, GroupLegacySchema])\n\nexport type NestableAndGroupLegacy = z.infer<typeof NestableAndGroupLegacySchema>\n"],"mappings":";;;AAIA,MAAa,wBAAwB,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC;AAItE,MAAa,oBAAoB,EAAE,MAAM,EAAE,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC,CAAC;AAIpF,MAAa,+BAA+B,EAAE,MAAM,CAAC,sBAAsB,kBAAkB,CAAC"}
+{"version":3,"file":"group.js","names":[],"sources":["../../../src/content/legacy/group.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { NestableLegacy } from \"./nestable\"\nimport { NestableLegacySchema } from \"./nestable\"\n\n// Keep item values raw here: array-shaped legacy payloads are ambiguous until\n// `codec/group.ts` resolves the field model and picks the right decoder.\nexport const GroupItemLegacySchema = z.record(z.string(), z.unknown())\n\nexport type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>\n\nexport const GroupLegacySchema: z.ZodMiniType<GroupLegacy> = z.array(\n\tz.union([GroupItemLegacySchema, z.null()]),\n)\n\nexport type GroupLegacy = (GroupItemLegacy | null)[]\n\nexport const NestableAndGroupLegacySchema: z.ZodMiniType<NestableAndGroupLegacy> = z.union([\n\tNestableLegacySchema,\n\tGroupLegacySchema,\n])\n\nexport type NestableAndGroupLegacy = NestableLegacy | GroupLegacy\n"],"mappings":";;;AAOA,MAAa,wBAAwB,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC;AAItE,MAAa,oBAAgD,EAAE,MAC9D,EAAE,MAAM,CAAC,uBAAuB,EAAE,MAAM,CAAC,CAAC,CAC1C;AAID,MAAa,+BAAsE,EAAE,MAAM,CAC1F,sBACA,kBACA,CAAC"}

package/dist/content/legacy/link.d.ts

@@ -0,0 +1,41 @@
+import { z } from "zod/mini";
+
+//#region src/content/legacy/link.d.ts
+declare const FilledImageLinkValueLegacySchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<"image", string>>;
+  id: z.ZodMiniString<string>;
+  url: z.ZodMiniString<string>;
+  height: z.ZodMiniString<string>;
+  width: z.ZodMiniString<string>;
+  size: z.ZodMiniString<string>;
+  name: z.ZodMiniString<string>;
+  date: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strict>;
+declare const FilledFileLinkValueLegacySchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniString<string>, z.ZodMiniTransform<"file", string>>;
+  id: z.ZodMiniString<string>;
+  url: z.ZodMiniString<string>;
+  name: z.ZodMiniString<string>;
+  size: z.ZodMiniTransform<string, unknown>;
+  date: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strict>;
+declare const FilledDocumentLinkValueLegacySchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniLiteral<"document">>, z.ZodMiniTransform<"document", "document" | undefined>>;
+  id: z.ZodMiniString<string>;
+}, z.core.$strict>;
+declare const FilledExternalLinkValueLegacySchema: z.ZodMiniObject<{
+  kind: z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniLiteral<"web">>, z.ZodMiniTransform<"web", "web" | undefined>>;
+  url: z.ZodMiniString<string>;
+  target: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  preview: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniObject<{
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  }, z.core.$strict>>>;
+}, z.core.$strict>;
+type FilledImageLinkValueLegacy = z.infer<typeof FilledImageLinkValueLegacySchema>;
+type FilledFileLinkValueLegacy = z.infer<typeof FilledFileLinkValueLegacySchema>;
+type FilledDocumentLinkValueLegacy = z.infer<typeof FilledDocumentLinkValueLegacySchema>;
+type FilledExternalLinkValueLegacy = z.infer<typeof FilledExternalLinkValueLegacySchema>;
+type FilledLinkValueLegacy = FilledImageLinkValueLegacy | FilledFileLinkValueLegacy | FilledDocumentLinkValueLegacy | FilledExternalLinkValueLegacy;
+//#endregion
+export { FilledLinkValueLegacy };
+//# sourceMappingURL=link.d.ts.map

package/dist/content/legacy/link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link.d.ts","names":[],"sources":["../../../src/content/legacy/link.ts"],"mappings":";;;cAuBa,gCAAA,EAAgC,CAAA,CAAA,aAAA;;;;;;;;;;cAoBhC,+BAAA,EAA+B,CAAA,CAAA,aAAA;;;;;;;;cA0B/B,mCAAA,EAAmC,CAAA,CAAA,aAAA;;;;cAenC,mCAAA,EAAmC,CAAA,CAAA,aAAA;;;;;;;;KAkC3C,0BAAA,GAA6B,CAAA,CAAE,KAAA,QAAa,gCAAA;AAAA,KAC5C,yBAAA,GAA4B,CAAA,CAAE,KAAA,QAAa,+BAAA;AAAA,KAC3C,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,mCAAA;AAAA,KAC/C,6BAAA,GAAgC,CAAA,CAAE,KAAA,QAAa,mCAAA;AAAA,KACxC,qBAAA,GACT,0BAAA,GACA,yBAAA,GACA,6BAAA,GACA,6BAAA"}

package/dist/content/legacy/link.js.map

@@ -1 +1 @@
-{"version":3,"file":"link.js","names":[],"sources":["../../../src/content/legacy/link.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { NonEmptyStringSchema } from \"../../common/nonEmptyString\"\n\nexport const LinkKind = {\n\tImage: \"image\",\n\tFile: \"file\",\n\tMedia: \"media\",\n\tDocument: \"document\",\n\tExternal: \"web\",\n\tAny: \"any\",\n} as const\n\nexport const LinkType = {\n\tImage: \"ImageLink\",\n\tFile: \"FileLink\",\n\tDocument: \"DocumentLink\",\n\tExternal: \"ExternalLink\",\n\tMedia: \"MediaLink\",\n\tAny: \"AnyLink\",\n} as const\n\n// Image\nexport const FilledImageLinkValueLegacySchema = z.strictObject({\n\t// `kind` was normalized to the literal (legacy behavior)\n\tkind: z.pipe(\n\t\tz.string(),\n\t\tz.transform(() => LinkKind.Image),\n\t),\n\tid: z.string(),\n\turl: z.string(),\n\theight: z.string(),\n\twidth: z.string(),\n\tsize: z.string(),\n\tname: z.string(),\n\tdate: z.nullish(z.string()),\n})\n\nexport const EmptyImageLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Image),\n})\n\n// File\nexport const FilledFileLinkValueLegacySchema = z.strictObject({\n\t// `kind` was normalized to the literal (legacy behavior)\n\tkind: z.pipe(\n\t\tz.string(),\n\t\tz.transform(() => LinkKind.File),\n\t),\n\tid: z.string(),\n\turl: z.string(),\n\tname: z.string(),\n\tsize: z.transform((value) => (typeof value === \"string\" ? value : \"0\")),\n\tdate: z.nullish(z.string()),\n})\n\nexport const EmptyFileLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.File),\n})\n\n// Media\n\n// Media link only represent the empty state as they turn into\n// file or image links when they filled.\nexport const EmptyMediaLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Media),\n})\n\n// Document\nexport const FilledDocumentLinkValueLegacySchema = z.strictObject({\n\t// `kind` is not part of the filled schema... (legacy behavior)\n\t// We transform it to the literal for consistency.\n\tkind: z.pipe(\n\t\tz.optional(z.literal(LinkKind.Document)),\n\t\tz.transform(() => LinkKind.Document),\n\t),\n\tid: NonEmptyStringSchema,\n})\n\nexport const EmptyDocumentLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Document),\n})\n\n// External\nexport const FilledExternalLinkValueLegacySchema = z.strictObject({\n\t// It's odd that `kind` is optional here... (legacy behavior)\n\t// We transform it to the literal for consistency.\n\tkind: z.pipe(\n\t\tz.optional(z.literal(LinkKind.External)),\n\t\tz.transform(() => LinkKind.External),\n\t),\n\turl: z.string(),\n\ttarget: z.nullish(z.string()),\n\tpreview: z.nullish(\n\t\tz.strictObject({\n\t\t\ttitle: z.optional(z.string()),\n\t\t}),\n\t),\n})\n\nexport const EmptyExternalLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.External),\n})\n\n// Any\nexport const AnyLinkLegacySchema = z.strictObject({\n\tkind: z.transform(() => LinkKind.Any),\n})\n\n// All\n\nexport const FilledLinkValueLegacySchema = z.union([\n\tFilledImageLinkValueLegacySchema,\n\tFilledFileLinkValueLegacySchema,\n\tFilledDocumentLinkValueLegacySchema,\n\tFilledExternalLinkValueLegacySchema,\n])\n\nexport type FilledLinkValueLegacy = z.infer<typeof FilledLinkValueLegacySchema>\n\nconst EmptyLinkValueLegacySchema = z.union([\n\tEmptyImageLinkValueLegacySchema,\n\tEmptyFileLinkValueLegacySchema,\n\tEmptyMediaLinkValueLegacySchema,\n\tEmptyDocumentLinkValueLegacySchema,\n\tEmptyExternalLinkValueLegacySchema,\n\tAnyLinkLegacySchema,\n])\n\nexport type EmptyLinkValueLegacy = z.infer<typeof EmptyLinkValueLegacySchema>\n\nconst LinkValueLegacySchema = z.union([FilledLinkValueLegacySchema, EmptyLinkValueLegacySchema])\n\nexport type LinkValueLegacy = z.infer<typeof LinkValueLegacySchema>\n\n// We cannot use z.extend here because we're working with unions.\n// z.intersection wouldn't work also for the same reason.\nexport const LinkLegacySchema = z.pipe(\n\tz.pipe(\n\t\tz.pipe(\n\t\t\tz.record(z.string(), z.unknown()),\n\t\t\tz.transform(\n\t\t\t\t({\n\t\t\t\t\tkey,\n\t\t\t\t\ttext,\n\t\t\t\t\tvariant,\n\t\t\t\t\t...value\n\t\t\t\t}): {\n\t\t\t\t\tkey?: unknown\n\t\t\t\t\ttext?: unknown\n\t\t\t\t\tvariant?: unknown\n\t\t\t\t\tvalue: Record<string, unknown>\n\t\t\t\t} => ({ key, text, variant, value }),\n\t\t\t),\n\t\t),\n\t\tz.object({\n\t\t\tkey: z.optional(z.string()),\n\t\t\ttext: z.optional(z.string()),\n\t\t\tvariant: z.optional(z.string()),\n\t\t\tvalue: LinkValueLegacySchema,\n\t\t}),\n\t),\n\tz.transform(({ key, text, variant, value }) => ({\n\t\tkey: z.uuidv4().safeParse(key).data ?? crypto.randomUUID(),\n\t\t...(text ? { text } : {}),\n\t\t...(variant ? { variant } : {}),\n\t\t...value,\n\t})),\n)\n\nexport type LinkLegacy = z.infer<typeof LinkLegacySchema>\n"],"mappings":"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"}
+{"version":3,"file":"link.js","names":[],"sources":["../../../src/content/legacy/link.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { NonEmptyStringSchema } from \"../../common/nonEmptyString\"\n\nexport const LinkKind = {\n\tImage: \"image\",\n\tFile: \"file\",\n\tMedia: \"media\",\n\tDocument: \"document\",\n\tExternal: \"web\",\n\tAny: \"any\",\n} as const\n\nexport const LinkType = {\n\tImage: \"ImageLink\",\n\tFile: \"FileLink\",\n\tDocument: \"DocumentLink\",\n\tExternal: \"ExternalLink\",\n\tMedia: \"MediaLink\",\n\tAny: \"AnyLink\",\n} as const\n\n// Image\nexport const FilledImageLinkValueLegacySchema = z.strictObject({\n\t// `kind` was normalized to the literal (legacy behavior)\n\tkind: z.pipe(\n\t\tz.string(),\n\t\tz.transform(() => LinkKind.Image),\n\t),\n\tid: z.string(),\n\turl: z.string(),\n\theight: z.string(),\n\twidth: z.string(),\n\tsize: z.string(),\n\tname: z.string(),\n\tdate: z.nullish(z.string()),\n})\n\nexport const EmptyImageLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Image),\n})\n\n// File\nexport const FilledFileLinkValueLegacySchema = z.strictObject({\n\t// `kind` was normalized to the literal (legacy behavior)\n\tkind: z.pipe(\n\t\tz.string(),\n\t\tz.transform(() => LinkKind.File),\n\t),\n\tid: z.string(),\n\turl: z.string(),\n\tname: z.string(),\n\tsize: z.transform((value) => (typeof value === \"string\" ? value : \"0\")),\n\tdate: z.nullish(z.string()),\n})\n\nexport const EmptyFileLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.File),\n})\n\n// Media\n\n// Media link only represent the empty state as they turn into\n// file or image links when they filled.\nexport const EmptyMediaLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Media),\n})\n\n// Document\nexport const FilledDocumentLinkValueLegacySchema = z.strictObject({\n\t// `kind` is not part of the filled schema... (legacy behavior)\n\t// We transform it to the literal for consistency.\n\tkind: z.pipe(\n\t\tz.optional(z.literal(LinkKind.Document)),\n\t\tz.transform(() => LinkKind.Document),\n\t),\n\tid: NonEmptyStringSchema,\n})\n\nexport const EmptyDocumentLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.Document),\n})\n\n// External\nexport const FilledExternalLinkValueLegacySchema = z.strictObject({\n\t// It's odd that `kind` is optional here... (legacy behavior)\n\t// We transform it to the literal for consistency.\n\tkind: z.pipe(\n\t\tz.optional(z.literal(LinkKind.External)),\n\t\tz.transform(() => LinkKind.External),\n\t),\n\turl: z.string(),\n\ttarget: z.nullish(z.string()),\n\tpreview: z.nullish(\n\t\tz.strictObject({\n\t\t\ttitle: z.optional(z.string()),\n\t\t}),\n\t),\n})\n\nexport const EmptyExternalLinkValueLegacySchema = z.strictObject({\n\tkind: z.literal(LinkKind.External),\n})\n\n// Any\nexport const AnyLinkLegacySchema = z.strictObject({\n\tkind: z.transform(() => LinkKind.Any),\n})\n\n// All\n\nexport const FilledLinkValueLegacySchema: z.ZodMiniType<FilledLinkValueLegacy> = z.union([\n\tFilledImageLinkValueLegacySchema,\n\tFilledFileLinkValueLegacySchema,\n\tFilledDocumentLinkValueLegacySchema,\n\tFilledExternalLinkValueLegacySchema,\n])\n\ntype FilledImageLinkValueLegacy = z.infer<typeof FilledImageLinkValueLegacySchema>\ntype FilledFileLinkValueLegacy = z.infer<typeof FilledFileLinkValueLegacySchema>\ntype FilledDocumentLinkValueLegacy = z.infer<typeof FilledDocumentLinkValueLegacySchema>\ntype FilledExternalLinkValueLegacy = z.infer<typeof FilledExternalLinkValueLegacySchema>\nexport type FilledLinkValueLegacy =\n\t| FilledImageLinkValueLegacy\n\t| FilledFileLinkValueLegacy\n\t| FilledDocumentLinkValueLegacy\n\t| FilledExternalLinkValueLegacy\n\nconst EmptyLinkValueLegacySchema: z.ZodMiniType<EmptyLinkValueLegacy> = z.union([\n\tEmptyImageLinkValueLegacySchema,\n\tEmptyFileLinkValueLegacySchema,\n\tEmptyMediaLinkValueLegacySchema,\n\tEmptyDocumentLinkValueLegacySchema,\n\tEmptyExternalLinkValueLegacySchema,\n\tAnyLinkLegacySchema,\n])\n\ntype EmptyImageLinkValueLegacy = z.infer<typeof EmptyImageLinkValueLegacySchema>\ntype EmptyFileLinkValueLegacy = z.infer<typeof EmptyFileLinkValueLegacySchema>\ntype EmptyMediaLinkValueLegacy = z.infer<typeof EmptyMediaLinkValueLegacySchema>\ntype EmptyDocumentLinkValueLegacy = z.infer<typeof EmptyDocumentLinkValueLegacySchema>\ntype EmptyExternalLinkValueLegacy = z.infer<typeof EmptyExternalLinkValueLegacySchema>\ntype AnyLinkLegacy = z.infer<typeof AnyLinkLegacySchema>\nexport type EmptyLinkValueLegacy =\n\t| EmptyImageLinkValueLegacy\n\t| EmptyFileLinkValueLegacy\n\t| EmptyMediaLinkValueLegacy\n\t| EmptyDocumentLinkValueLegacy\n\t| EmptyExternalLinkValueLegacy\n\t| AnyLinkLegacy\n\nconst LinkValueLegacySchema: z.ZodMiniType<LinkValueLegacy> = z.union([\n\tFilledLinkValueLegacySchema,\n\tEmptyLinkValueLegacySchema,\n])\n\nexport type LinkValueLegacy = FilledLinkValueLegacy | EmptyLinkValueLegacy\n\n// We cannot use z.extend here because we're working with unions.\n// z.intersection wouldn't work also for the same reason.\nexport const LinkLegacySchema = z.pipe(\n\tz.pipe(\n\t\tz.pipe(\n\t\t\tz.record(z.string(), z.unknown()),\n\t\t\tz.transform(\n\t\t\t\t({\n\t\t\t\t\tkey,\n\t\t\t\t\ttext,\n\t\t\t\t\tvariant,\n\t\t\t\t\t...value\n\t\t\t\t}): {\n\t\t\t\t\tkey?: unknown\n\t\t\t\t\ttext?: unknown\n\t\t\t\t\tvariant?: unknown\n\t\t\t\t\tvalue: Record<string, unknown>\n\t\t\t\t} => ({ key, text, variant, value }),\n\t\t\t),\n\t\t),\n\t\tz.object({\n\t\t\tkey: z.optional(z.string()),\n\t\t\ttext: z.optional(z.string()),\n\t\t\tvariant: z.optional(z.string()),\n\t\t\tvalue: LinkValueLegacySchema as z.ZodMiniType<LinkValueLegacy, Record<string, unknown>>,\n\t\t}),\n\t),\n\tz.transform(({ key, text, variant, value }) => ({\n\t\tkey: z.uuidv4().safeParse(key).data ?? crypto.randomUUID(),\n\t\t...(text ? { text } : {}),\n\t\t...(variant ? { variant } : {}),\n\t\t...value,\n\t})),\n)\n\nexport type LinkLegacy = z.infer<typeof LinkLegacySchema>\n"],"mappings":"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"}

package/dist/content/legacy/nestable.js.map

@@ -1 +1 @@
-{"version":3,"file":"nestable.js","names":[],"sources":["../../../src/content/legacy/nestable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { BooleanLegacySchema } from \"./boolean\"\nimport { EmbedLegacyLooseSchema } from \"./embed\"\nimport { EmptyLegacySchema } from \"./empty\"\nimport { StringLegacySchema } from \"./field\"\nimport { GeoPointLegacySchema } from \"./geopoint\"\nimport { ImageLegacySchema } from \"./image\"\nimport { IntegrationFieldLegacySchema } from \"./integrationField\"\nimport { LinkLegacySchema } from \"./link\"\nimport { RepeatableLegacySchema } from \"./repeatable\"\nimport { RichTextLegacySchema } from \"./richText\"\nimport { SeparatorLegacySchema } from \"./separator\"\nimport { TableLegacySchema } from \"./table\"\n\nexport const NestableLegacySchema = z.union([\n\tEmptyLegacySchema,\n\tBooleanLegacySchema,\n\tEmbedLegacyLooseSchema,\n\tStringLegacySchema,\n\tGeoPointLegacySchema,\n\tImageLegacySchema,\n\tIntegrationFieldLegacySchema,\n\tLinkLegacySchema,\n\tRepeatableLegacySchema,\n\tRichTextLegacySchema,\n\tSeparatorLegacySchema,\n\tTableLegacySchema,\n])\n\nexport type NestableLegacy = z.infer<typeof NestableLegacySchema>\n"],"mappings":";;;;;;;;;;;;;;AAeA,MAAa,uBAAuB,EAAE,MAAM;CAC3C;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC"}
+{"version":3,"file":"nestable.js","names":[],"sources":["../../../src/content/legacy/nestable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport type { BooleanLegacy } from \"./boolean\"\nimport { BooleanLegacySchema } from \"./boolean\"\nimport type { EmbedLegacy } from \"./embed\"\nimport { EmbedLegacyLooseSchema } from \"./embed\"\nimport type { EmptyLegacy } from \"./empty\"\nimport { EmptyLegacySchema } from \"./empty\"\nimport type { StringLegacy } from \"./field\"\nimport { StringLegacySchema } from \"./field\"\nimport type { GeoPointLegacy } from \"./geopoint\"\nimport { GeoPointLegacySchema } from \"./geopoint\"\nimport type { ImageLegacy } from \"./image\"\nimport { ImageLegacySchema } from \"./image\"\nimport type { IntegrationFieldLegacy } from \"./integrationField\"\nimport { IntegrationFieldLegacySchema } from \"./integrationField\"\nimport type { LinkLegacy } from \"./link\"\nimport { LinkLegacySchema } from \"./link\"\nimport type { RepeatableLegacy } from \"./repeatable\"\nimport { RepeatableLegacySchema } from \"./repeatable\"\nimport type { RichTextLegacy } from \"./richText\"\nimport { RichTextLegacySchema } from \"./richText\"\nimport type { SeparatorLegacy } from \"./separator\"\nimport { SeparatorLegacySchema } from \"./separator\"\nimport type { TableLegacy } from \"./table\"\nimport { TableLegacySchema } from \"./table\"\n\nexport const NestableLegacySchema: z.ZodMiniType<NestableLegacy> = z.union([\n\tEmptyLegacySchema,\n\tBooleanLegacySchema,\n\tEmbedLegacyLooseSchema,\n\tStringLegacySchema,\n\tGeoPointLegacySchema,\n\tImageLegacySchema,\n\tIntegrationFieldLegacySchema,\n\tLinkLegacySchema,\n\tRepeatableLegacySchema,\n\tRichTextLegacySchema,\n\tSeparatorLegacySchema,\n\tTableLegacySchema,\n])\n\nexport type NestableLegacy =\n\t| EmptyLegacy\n\t| BooleanLegacy\n\t| EmbedLegacy\n\t| StringLegacy\n\t| GeoPointLegacy\n\t| ImageLegacy\n\t| IntegrationFieldLegacy\n\t| LinkLegacy\n\t| RepeatableLegacy\n\t| RichTextLegacy\n\t| SeparatorLegacy\n\t| TableLegacy\n"],"mappings":";;;;;;;;;;;;;;AA2BA,MAAa,uBAAsD,EAAE,MAAM;CAC1E;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA,CAAC"}

package/dist/content/legacy/repeatable.js

@@ -1,12 +1,6 @@
-import { LinkLegacySchema } from "./link.js";
 import { z } from "zod/mini";
-const RepeatableLegacySchema = z.pipe(z.array(z.unknown()), z.transform((value) => value.flatMap((item) => {
-	try {
-		return [LinkLegacySchema.parse(item)];
-	} catch {
-		return [];
-	}
-})));
+//#region src/content/legacy/repeatable.ts
+const RepeatableLegacySchema = z.array(z.unknown());
 //#endregion
 export { RepeatableLegacySchema };
 

package/dist/content/legacy/repeatable.js.map

@@ -1 +1 @@
-{"version":3,"file":"repeatable.js","names":[],"sources":["../../../src/content/legacy/repeatable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { LinkLegacySchema } from \"./link\"\n\nconst RepeatableLinkLegacySchema = z.pipe(\n\tz.array(z.unknown()),\n\tz.transform((value) =>\n\t\tvalue.flatMap((item) => {\n\t\t\ttry {\n\t\t\t\treturn [LinkLegacySchema.parse(item)]\n\t\t\t} catch {\n\t\t\t\treturn []\n\t\t\t}\n\t\t}),\n\t),\n)\n\nexport const RepeatableLegacySchema = RepeatableLinkLegacySchema\n\nexport type RepeatableLegacy = z.infer<typeof RepeatableLegacySchema>\n"],"mappings":";;AAiBA,MAAa,yBAbsB,EAAE,KACpC,EAAE,MAAM,EAAE,SAAS,CAAC,EACpB,EAAE,WAAW,UACZ,MAAM,SAAS,SAAS;AACvB,KAAI;AACH,SAAO,CAAC,iBAAiB,MAAM,KAAK,CAAC;SAC9B;AACP,SAAO,EAAE;;EAET,CACF,CACD"}
+{"version":3,"file":"repeatable.js","names":[],"sources":["../../../src/content/legacy/repeatable.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\n// Keep the legacy schema non-lossy; item-level link decoding lives in\n// `codec/repeatable.ts`, where the field model is available.\nexport const RepeatableLegacySchema = z.array(z.unknown())\n\nexport type RepeatableLegacy = z.infer<typeof RepeatableLegacySchema>\n"],"mappings":";;AAIA,MAAa,yBAAyB,EAAE,MAAM,EAAE,SAAS,CAAC"}

package/dist/content/legacy/richText.d.ts

@@ -0,0 +1,109 @@
+import { FilledLinkValueContent } from "../link.js";
+import { FilledLinkValueLegacy } from "./link.js";
+import { z } from "zod/mini";
+
+//#region src/content/legacy/richText.d.ts
+declare const RichTextNodeType: {
+  readonly paragraph: "paragraph";
+  readonly heading1: "heading1";
+  readonly heading2: "heading2";
+  readonly heading3: "heading3";
+  readonly heading4: "heading4";
+  readonly heading5: "heading5";
+  readonly heading6: "heading6";
+  readonly preformatted: "preformatted";
+  readonly oListItem: "o-list-item";
+  readonly listItem: "list-item";
+  readonly image: "image";
+  readonly embed: "embed";
+  readonly hyperlink: "hyperlink";
+  readonly strong: "strong";
+  readonly em: "em";
+};
+type HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent> = {
+  type: typeof RichTextNodeType.hyperlink;
+  start: number;
+  end: number;
+  data: TData;
+};
+type LabelSpan = {
+  type: "label";
+  start: number;
+  end: number;
+  data: string;
+};
+type BasicSpan = {
+  type: typeof RichTextNodeType.strong | typeof RichTextNodeType.em | "list-item";
+  start: number;
+  end: number;
+};
+type Span<TLink extends FilledLinkValueLegacy | FilledLinkValueContent> = HyperlinkSpan<TLink> | LabelSpan | BasicSpan;
+declare const TextBlockLegacySchema: z.ZodMiniObject<{
+  type: z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"paragraph">, z.ZodMiniLiteral<"heading1">, z.ZodMiniLiteral<"heading2">, z.ZodMiniLiteral<"heading3">, z.ZodMiniLiteral<"heading4">, z.ZodMiniLiteral<"heading5">, z.ZodMiniLiteral<"heading6">, z.ZodMiniLiteral<"preformatted">, z.ZodMiniLiteral<"o-list-item">, z.ZodMiniLiteral<"list-item">]>;
+  content: z.ZodMiniObject<{
+    text: z.ZodMiniString<string>;
+    spans: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniArray<z.ZodMiniUnknown>, z.ZodMiniTransform<(LabelSpan | BasicSpan | {
+      type: "hyperlink";
+      start: number;
+      end: number;
+      data: FilledLinkValueLegacy;
+    })[], unknown[]>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniString<string>>;
+  direction: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strip>;
+type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>;
+declare const ImageBlockLegacySchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"image">;
+  data: z.ZodMiniObject<{
+    origin: z.ZodMiniObject<{
+      id: z.ZodMiniString<string>;
+      url: z.ZodMiniString<string>;
+      width: z.ZodMiniNumber<number>;
+      height: z.ZodMiniNumber<number>;
+    }, z.core.$strip>;
+    width: z.ZodMiniNumber<number>;
+    height: z.ZodMiniNumber<number>;
+    edit: z.ZodMiniObject<{
+      zoom: z.ZodMiniNumber<number>;
+      crop: z.ZodMiniObject<{
+        x: z.ZodMiniNumber<number>;
+        y: z.ZodMiniNumber<number>;
+      }, z.core.$strip>;
+      background: z.ZodMiniString<string>;
+    }, z.core.$strip>;
+    url: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    credits: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>, z.ZodMiniTransform<string | null, string | null | undefined>>>;
+    alt: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>, z.ZodMiniTransform<string | null, string | null | undefined>>>;
+    provider: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    linkTo: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniType<FilledLinkValueLegacy, unknown, z.core.$ZodTypeInternals<FilledLinkValueLegacy, unknown>>>>;
+  }, z.core.$strip>;
+  label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  direction: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>;
+declare const EmbedBlockLegacySchema: z.ZodMiniObject<{
+  type: z.ZodMiniLiteral<"embed">;
+  data: z.ZodMiniObject<{
+    embed_url: z.ZodMiniString<string>;
+    type: z.ZodMiniString<string>;
+    version: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+    title: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    author_name: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    author_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    provider_name: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    provider_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    cache_age: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniUnion<readonly [z.ZodMiniString<string>, z.ZodMiniNumber<number>]>>>;
+    thumbnail_url: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+    thumbnail_width: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
+    thumbnail_height: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniNumber<number>>>;
+    html: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  }, z.core.$loose>;
+  label: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+  direction: z.ZodMiniOptional<z.ZodMiniNullable<z.ZodMiniString<string>>>;
+}, z.core.$strip>;
+type EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>;
+type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy;
+//#endregion
+export { RichTextLegacyBlock, Span };
+//# sourceMappingURL=richText.d.ts.map

package/dist/content/legacy/richText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"richText.d.ts","names":[],"sources":["../../../src/content/legacy/richText.ts"],"mappings":";;;;;cAYa,gBAAA;EAAA;;;;;;;;;;;;;;;;KAmBR,aAAA,eAA4B,qBAAA,GAAwB,sBAAA;EACxD,IAAA,SAAa,gBAAA,CAAiB,SAAA;EAC9B,KAAA;EACA,GAAA;EACA,IAAA,EAAM,KAAA;AAAA;AAAA,KAeF,SAAA;EACJ,IAAA;EACA,KAAA;EACA,GAAA;EACA,IAAA;AAAA;AAAA,KAaI,SAAA;EACJ,IAAA,SAAa,gBAAA,CAAiB,MAAA,UAAgB,gBAAA,CAAiB,EAAA;EAC/D,KAAA;EACA,GAAA;AAAA;AAAA,KAaW,IAAA,eAAmB,qBAAA,GAAwB,sBAAA,IACpD,aAAA,CAAc,KAAA,IACd,SAAA,GACA,SAAA;AAAA,cAsDG,qBAAA,EAAqB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;KAEtB,eAAA,GAAkB,CAAA,CAAE,KAAA,QAAa,qBAAA;AAAA,cAmBhC,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAKvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,cAgBjC,sBAAA,EAAsB,CAAA,CAAA,aAAA;;;;;;;;;;;;;;;;;;;;KAEvB,gBAAA,GAAmB,CAAA,CAAE,KAAA,QAAa,sBAAA;AAAA,KAS3B,mBAAA,GAAsB,eAAA,GAAkB,gBAAA,GAAmB,gBAAA"}

package/dist/content/legacy/richText.js.map

@@ -1 +1 @@
-{"version":3,"file":"richText.js","names":[],"sources":["../../../src/content/legacy/richText.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\n// It's important to only import the types here to\n// avoid runtime circular dependencies!\nimport type { EmbedContentSchema } from \"../embed\"\nimport type { ImageViewContentSchema } from \"../image\"\nimport type { FilledLinkValueContentSchema } from \"../link\"\nimport { EmbedLegacyLooseSchema } from \"./embed\"\nimport { ImageViewLegacySchema } from \"./image\"\nimport { FilledLinkValueLegacySchema } from \"./link\"\n\nexport const RichTextNodeType = {\n\tparagraph: \"paragraph\",\n\theading1: \"heading1\",\n\theading2: \"heading2\",\n\theading3: \"heading3\",\n\theading4: \"heading4\",\n\theading5: \"heading5\",\n\theading6: \"heading6\",\n\tpreformatted: \"preformatted\",\n\toListItem: \"o-list-item\",\n\tlistItem: \"list-item\",\n\timage: \"image\",\n\tembed: \"embed\",\n\thyperlink: \"hyperlink\",\n\tstrong: \"strong\",\n\tem: \"em\",\n} as const\n\n// Spans\nconst getHyperlinkSpanSchema = <\n\tTData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tdata: TData,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.hyperlink),\n\t\tstart: z.number(),\n\t\tend: z.number(),\n\t\tdata,\n\t})\n\nconst LabelSpanSchema = z.object({\n\ttype: z.literal(\"label\"),\n\tstart: z.number(),\n\tend: z.number(),\n\tdata: z.pipe(\n\t\tz.unknown(),\n\t\tz.transform((value) => (typeof value === \"string\" && value.length > 0 ? value : \"\")),\n\t),\n})\n\nconst BasicSpanSchema = z.object({\n\ttype: z.union([\n\t\tz.literal(RichTextNodeType.strong),\n\t\tz.literal(RichTextNodeType.em),\n\t\tz.literal(\"list-item\"), // legacy case\n\t]),\n\tstart: z.number(),\n\tend: z.number(),\n})\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getSpanSchema = <\n\tTLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tlinkSchema: TLinkSchema,\n) => z.union([getHyperlinkSpanSchema(linkSchema), LabelSpanSchema, BasicSpanSchema])\n\n// Text blocks\nconst TextBlockTypeSchema = z.union([\n\tz.literal(RichTextNodeType.paragraph),\n\tz.literal(RichTextNodeType.heading1),\n\tz.literal(RichTextNodeType.heading2),\n\tz.literal(RichTextNodeType.heading3),\n\tz.literal(RichTextNodeType.heading4),\n\tz.literal(RichTextNodeType.heading5),\n\tz.literal(RichTextNodeType.heading6),\n\tz.literal(RichTextNodeType.preformatted),\n\tz.literal(RichTextNodeType.oListItem),\n\tz.literal(RichTextNodeType.listItem),\n])\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getTextBlockSchema = <\n\tTLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tlinkSchema: TLinkSchema,\n) =>\n\tz.object({\n\t\ttype: TextBlockTypeSchema,\n\t\tcontent: z.object({\n\t\t\ttext: z.string(),\n\t\t\tspans: z.optional(\n\t\t\t\tz.pipe(\n\t\t\t\t\tz.array(z.unknown()),\n\t\t\t\t\tz.transform((spans) => {\n\t\t\t\t\t\tconst spanSchema = getSpanSchema(linkSchema)\n\n\t\t\t\t\t\t// Filter out invalid spans and order them by start position\n\t\t\t\t\t\treturn spans\n\t\t\t\t\t\t\t.flatMap((maybeSpan) => {\n\t\t\t\t\t\t\t\tconst parsed = spanSchema.safeParse(maybeSpan)\n\t\t\t\t\t\t\t\treturn parsed.success ? [parsed.data] : []\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.sort((a, b) => a.start - b.start)\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t),\n\t\t}),\n\t\tlabel: z.optional(z.string()),\n\t\tdirection: z.optional(z.string()),\n\t})\n\nconst TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)\n\n// Image block\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getImageBlockSchema = <\n\tTData extends typeof ImageViewLegacySchema | typeof ImageViewContentSchema,\n\tTLinkTo extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tdata: TData,\n\tlinkTo: TLinkTo,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.image),\n\t\tdata: z.extend(data, { linkTo: z.nullish(linkTo) }),\n\t\tlabel: z.nullish(z.string()),\n\t\tdirection: z.nullish(z.string()),\n\t})\n\nconst ImageBlockLegacySchema = getImageBlockSchema(\n\tImageViewLegacySchema,\n\tFilledLinkValueLegacySchema,\n)\n\n// Embed block\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getEmbedBlockSchema = <\n\tTData extends typeof EmbedLegacyLooseSchema | typeof EmbedContentSchema,\n>(\n\tdata: TData,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.embed),\n\t\tdata,\n\t\tlabel: z.nullish(z.string()),\n\t\tdirection: z.nullish(z.string()),\n\t})\n\nconst EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)\n\n// Blocks\nexport const RichTextLegacyBlockSchema = z.union([\n\tTextBlockLegacySchema,\n\tImageBlockLegacySchema,\n\tEmbedBlockLegacySchema,\n])\n\nexport type RichTextLegacyBlock = z.infer<typeof RichTextLegacyBlockSchema>\n\nexport const RichTextLegacySchema = z.array(RichTextLegacyBlockSchema)\n\nexport type RichTextLegacy = z.infer<typeof RichTextLegacySchema>\n"],"mappings":"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"}
+{"version":3,"file":"richText.js","names":[],"sources":["../../../src/content/legacy/richText.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\n// It's important to only import the types here to\n// avoid runtime circular dependencies!\nimport type { EmbedContentSchema } from \"../embed\"\nimport type { ImageViewContentSchema } from \"../image\"\nimport type { FilledLinkValueContent, FilledLinkValueContentSchema } from \"../link\"\nimport { EmbedLegacyLooseSchema } from \"./embed\"\nimport { ImageViewLegacySchema } from \"./image\"\nimport { FilledLinkValueLegacySchema } from \"./link\"\nimport type { FilledLinkValueLegacy } from \"./link\"\n\nexport const RichTextNodeType = {\n\tparagraph: \"paragraph\",\n\theading1: \"heading1\",\n\theading2: \"heading2\",\n\theading3: \"heading3\",\n\theading4: \"heading4\",\n\theading5: \"heading5\",\n\theading6: \"heading6\",\n\tpreformatted: \"preformatted\",\n\toListItem: \"o-list-item\",\n\tlistItem: \"list-item\",\n\timage: \"image\",\n\tembed: \"embed\",\n\thyperlink: \"hyperlink\",\n\tstrong: \"strong\",\n\tem: \"em\",\n} as const\n\n// Spans\ntype HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent> = {\n\ttype: typeof RichTextNodeType.hyperlink\n\tstart: number\n\tend: number\n\tdata: TData\n}\n\nconst getHyperlinkSpanSchema = <\n\tTData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tdata: TData,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.hyperlink),\n\t\tstart: z.number(),\n\t\tend: z.number(),\n\t\tdata,\n\t})\n\ntype LabelSpan = {\n\ttype: \"label\"\n\tstart: number\n\tend: number\n\tdata: string\n}\n\nconst LabelSpanSchema: z.ZodMiniType<LabelSpan> = z.object({\n\ttype: z.literal(\"label\"),\n\tstart: z.number(),\n\tend: z.number(),\n\tdata: z.pipe(\n\t\tz.unknown(),\n\t\tz.transform((value) => (typeof value === \"string\" && value.length > 0 ? value : \"\")),\n\t),\n})\n\ntype BasicSpan = {\n\ttype: typeof RichTextNodeType.strong | typeof RichTextNodeType.em | \"list-item\"\n\tstart: number\n\tend: number\n}\n\nconst BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({\n\ttype: z.union([\n\t\tz.literal(RichTextNodeType.strong),\n\t\tz.literal(RichTextNodeType.em),\n\t\tz.literal(\"list-item\"), // legacy case\n\t]),\n\tstart: z.number(),\n\tend: z.number(),\n})\n\nexport type Span<TLink extends FilledLinkValueLegacy | FilledLinkValueContent> =\n\t| HyperlinkSpan<TLink>\n\t| LabelSpan\n\t| BasicSpan\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getSpanSchema = <\n\tTLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tlinkSchema: TLinkSchema,\n) => z.union([getHyperlinkSpanSchema(linkSchema), LabelSpanSchema, BasicSpanSchema])\n\n// Text blocks\nconst TextBlockTypeSchema = z.union([\n\tz.literal(RichTextNodeType.paragraph),\n\tz.literal(RichTextNodeType.heading1),\n\tz.literal(RichTextNodeType.heading2),\n\tz.literal(RichTextNodeType.heading3),\n\tz.literal(RichTextNodeType.heading4),\n\tz.literal(RichTextNodeType.heading5),\n\tz.literal(RichTextNodeType.heading6),\n\tz.literal(RichTextNodeType.preformatted),\n\tz.literal(RichTextNodeType.oListItem),\n\tz.literal(RichTextNodeType.listItem),\n])\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getTextBlockSchema = <\n\tTLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tlinkSchema: TLinkSchema,\n) =>\n\tz.object({\n\t\ttype: TextBlockTypeSchema,\n\t\tcontent: z.object({\n\t\t\ttext: z.string(),\n\t\t\tspans: z.optional(\n\t\t\t\tz.pipe(\n\t\t\t\t\tz.array(z.unknown()),\n\t\t\t\t\tz.transform((spans) => {\n\t\t\t\t\t\tconst spanSchema = getSpanSchema(linkSchema)\n\n\t\t\t\t\t\t// Filter out invalid spans and order them by start position\n\t\t\t\t\t\treturn spans\n\t\t\t\t\t\t\t.flatMap((maybeSpan) => {\n\t\t\t\t\t\t\t\tconst parsed = spanSchema.safeParse(maybeSpan)\n\t\t\t\t\t\t\t\treturn parsed.success ? [parsed.data] : []\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.sort((a, b) => a.start - b.start)\n\t\t\t\t\t}),\n\t\t\t\t),\n\t\t\t),\n\t\t}),\n\t\tlabel: z.optional(z.string()),\n\t\tdirection: z.optional(z.string()),\n\t})\n\nconst TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)\n\ntype TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>\n\n// Image block\n\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getImageBlockSchema = <\n\tTData extends typeof ImageViewLegacySchema | typeof ImageViewContentSchema,\n\tTLinkTo extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,\n>(\n\tdata: TData,\n\tlinkTo: TLinkTo,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.image),\n\t\tdata: z.extend(data, { linkTo: z.nullish(linkTo) }),\n\t\tlabel: z.nullish(z.string()),\n\t\tdirection: z.nullish(z.string()),\n\t})\n\nconst ImageBlockLegacySchema = getImageBlockSchema(\n\tImageViewLegacySchema,\n\tFilledLinkValueLegacySchema,\n)\n\ntype ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>\n\n// Embed block\n// oxlint-disable-next-line explicit-module-boundary-types\nexport const getEmbedBlockSchema = <\n\tTData extends typeof EmbedLegacyLooseSchema | typeof EmbedContentSchema,\n>(\n\tdata: TData,\n) =>\n\tz.object({\n\t\ttype: z.literal(RichTextNodeType.embed),\n\t\tdata,\n\t\tlabel: z.nullish(z.string()),\n\t\tdirection: z.nullish(z.string()),\n\t})\n\nconst EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)\n\ntype EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>\n\n// Blocks\nexport const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.union([\n\tTextBlockLegacySchema,\n\tImageBlockLegacySchema,\n\tEmbedBlockLegacySchema,\n])\n\nexport type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy\n\nexport const RichTextLegacySchema = z.array(RichTextLegacyBlockSchema)\n\nexport type RichTextLegacy = z.infer<typeof RichTextLegacySchema>\n"],"mappings":";;;;;AAYA,MAAa,mBAAmB;CAC/B,WAAW;CACX,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,UAAU;CACV,cAAc;CACd,WAAW;CACX,UAAU;CACV,OAAO;CACP,OAAO;CACP,WAAW;CACX,QAAQ;CACR,IAAI;CACJ;AAUD,MAAM,0BAGL,SAEA,EAAE,OAAO;CACR,MAAM,EAAE,QAAQ,iBAAiB,UAAU;CAC3C,OAAO,EAAE,QAAQ;CACjB,KAAK,EAAE,QAAQ;CACf;CACA,CAAC;AASH,MAAM,kBAA4C,EAAE,OAAO;CAC1D,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,QAAQ;CACjB,KAAK,EAAE,QAAQ;CACf,MAAM,EAAE,KACP,EAAE,SAAS,EACX,EAAE,WAAW,UAAW,OAAO,UAAU,YAAY,MAAM,SAAS,IAAI,QAAQ,GAAI,CACpF;CACD,CAAC;AAQF,MAAM,kBAA4C,EAAE,OAAO;CAC1D,MAAM,EAAE,MAAM;EACb,EAAE,QAAQ,iBAAiB,OAAO;EAClC,EAAE,QAAQ,iBAAiB,GAAG;EAC9B,EAAE,QAAQ,YAAY;EACtB,CAAC;CACF,OAAO,EAAE,QAAQ;CACjB,KAAK,EAAE,QAAQ;CACf,CAAC;AAQF,MAAa,iBAGZ,eACI,EAAE,MAAM;CAAC,uBAAuB,WAAW;CAAE;CAAiB;CAAgB,CAAC;AAGpF,MAAM,sBAAsB,EAAE,MAAM;CACnC,EAAE,QAAQ,iBAAiB,UAAU;CACrC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,EAAE,QAAQ,iBAAiB,aAAa;CACxC,EAAE,QAAQ,iBAAiB,UAAU;CACrC,EAAE,QAAQ,iBAAiB,SAAS;CACpC,CAAC;AAGF,MAAa,sBAGZ,eAEA,EAAE,OAAO;CACR,MAAM;CACN,SAAS,EAAE,OAAO;EACjB,MAAM,EAAE,QAAQ;EAChB,OAAO,EAAE,SACR,EAAE,KACD,EAAE,MAAM,EAAE,SAAS,CAAC,EACpB,EAAE,WAAW,UAAU;GACtB,MAAM,aAAa,cAAc,WAAW;AAG5C,UAAO,MACL,SAAS,cAAc;IACvB,MAAM,SAAS,WAAW,UAAU,UAAU;AAC9C,WAAO,OAAO,UAAU,CAAC,OAAO,KAAK,GAAG,EAAE;KACzC,CACD,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM;IAClC,CACF,CACD;EACD,CAAC;CACF,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC;CAC7B,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC;CACjC,CAAC;AAEH,MAAM,wBAAwB,mBAAmB,4BAA4B;AAO7E,MAAa,uBAIZ,MACA,WAEA,EAAE,OAAO;CACR,MAAM,EAAE,QAAQ,iBAAiB,MAAM;CACvC,MAAM,EAAE,OAAO,MAAM,EAAE,QAAQ,EAAE,QAAQ,OAAO,EAAE,CAAC;CACnD,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAChC,CAAC;AAEH,MAAM,yBAAyB,oBAC9B,uBACA,4BACA;AAMD,MAAa,uBAGZ,SAEA,EAAE,OAAO;CACR,MAAM,EAAE,QAAQ,iBAAiB,MAAM;CACvC;CACA,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAC5B,WAAW,EAAE,QAAQ,EAAE,QAAQ,CAAC;CAChC,CAAC;AAEH,MAAM,yBAAyB,oBAAoB,uBAAuB;AAK1E,MAAa,4BAAgE,EAAE,MAAM;CACpF;CACA;CACA;CACA,CAAC;AAIF,MAAa,uBAAuB,EAAE,MAAM,0BAA0B"}

package/dist/content/legacy/slice.js

@@ -1,15 +1,14 @@
-import { NestableLegacySchema } from "./nestable.js";
 import { GroupItemLegacySchema, NestableAndGroupLegacySchema } from "./group.js";
 import { z } from "zod/mini";
 //#region src/content/legacy/slice.ts
 const LegacySliceLegacySchema = NestableAndGroupLegacySchema;
 const CompositeSliceLegacySchema = z.object({
-	"non-repeat": z.optional(z.record(z.string(), NestableLegacySchema)),
+	"non-repeat": z.optional(z.record(z.string(), z.unknown())),
 	repeat: z.optional(z.array(GroupItemLegacySchema))
 });
 const SharedSliceLegacySchema = z.object({
 	variation: z.string(),
-	primary: z.transform((value) => z.record(z.string(), NestableAndGroupLegacySchema).safeParse(value).data || {}),
+	primary: z.transform((value) => z.record(z.string(), z.unknown()).safeParse(value).data || {}),
 	items: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || [])
 });
 const SliceLegacySchema = z.union([

package/dist/content/legacy/slice.js.map

@@ -1 +1 @@
-{"version":3,"file":"slice.js","names":[],"sources":["../../../src/content/legacy/slice.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { GroupItemLegacySchema, NestableAndGroupLegacySchema } from \"./group\"\nimport { NestableLegacySchema } from \"./nestable\"\n\n// Legacy (before 2020)\nexport const LegacySliceLegacySchema = NestableAndGroupLegacySchema\n\nexport type LegacySliceLegacy = z.infer<typeof LegacySliceLegacySchema>\n\n// Composite (2020 to 2021)\nexport const CompositeSliceLegacySchema = z.object({\n\t\"non-repeat\": z.optional(z.record(z.string(), NestableLegacySchema)),\n\trepeat: z.optional(z.array(GroupItemLegacySchema)),\n})\n\nexport type CompositeSliceLegacy = z.infer<typeof CompositeSliceLegacySchema>\n\n// Shared (2021 to present)\nexport const SharedSliceLegacySchema = z.object({\n\tvariation: z.string(),\n\tprimary: z.transform(\n\t\t(value) => z.record(z.string(), NestableAndGroupLegacySchema).safeParse(value).data || {},\n\t),\n\titems: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || []),\n})\n\nexport type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>\n\n// All\nexport const SliceLegacySchema = z.union([\n\tLegacySliceLegacySchema,\n\tCompositeSliceLegacySchema,\n\tSharedSliceLegacySchema,\n])\n\nexport type SliceLegacy = z.infer<typeof SliceLegacySchema>\n"],"mappings":";;;;AAMA,MAAa,0BAA0B;AAKvC,MAAa,6BAA6B,EAAE,OAAO;CAClD,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,qBAAqB,CAAC;CACpE,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;CAClD,CAAC;AAKF,MAAa,0BAA0B,EAAE,OAAO;CAC/C,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,WACT,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,CAAC,UAAU,MAAM,CAAC,QAAQ,EAAE,CACzF;CACD,OAAO,EAAE,WAAW,UAAU,EAAE,MAAM,sBAAsB,CAAC,UAAU,MAAM,CAAC,QAAQ,EAAE,CAAC;CACzF,CAAC;AAKF,MAAa,oBAAoB,EAAE,MAAM;CACxC;CACA;CACA;CACA,CAAC"}
+{"version":3,"file":"slice.js","names":[],"sources":["../../../src/content/legacy/slice.ts"],"sourcesContent":["import { z } from \"zod/mini\"\n\nimport { GroupItemLegacySchema, NestableAndGroupLegacySchema } from \"./group\"\n\n// Legacy (before 2020)\nexport const LegacySliceLegacySchema = NestableAndGroupLegacySchema\n\nexport type LegacySliceLegacy = z.infer<typeof LegacySliceLegacySchema>\n\n// Composite (2020 to 2021)\n// Keep non-repeat values raw here: array-shaped legacy payloads are ambiguous until\n// `codec/slice.ts` resolves the field model and picks the right decoder.\nexport const CompositeSliceLegacySchema = z.object({\n\t\"non-repeat\": z.optional(z.record(z.string(), z.unknown())),\n\trepeat: z.optional(z.array(GroupItemLegacySchema)),\n})\n\nexport type CompositeSliceLegacy = z.infer<typeof CompositeSliceLegacySchema>\n\n// Shared (2021 to present)\n// Keep primary values raw here: array-shaped legacy payloads are ambiguous until\n// `codec/slice.ts` resolves the field model and picks the right decoder.\nexport const SharedSliceLegacySchema = z.object({\n\tvariation: z.string(),\n\tprimary: z.transform((value) => z.record(z.string(), z.unknown()).safeParse(value).data || {}),\n\titems: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || []),\n})\n\nexport type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>\n\n// All\nexport const SliceLegacySchema: z.ZodMiniType<SliceLegacy> = z.union([\n\tLegacySliceLegacySchema,\n\tCompositeSliceLegacySchema,\n\tSharedSliceLegacySchema,\n])\n\nexport type SliceLegacy = LegacySliceLegacy | CompositeSliceLegacy | SharedSliceLegacy\n"],"mappings":";;;AAKA,MAAa,0BAA0B;AAOvC,MAAa,6BAA6B,EAAE,OAAO;CAClD,cAAc,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC;CAC3D,QAAQ,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;CAClD,CAAC;AAOF,MAAa,0BAA0B,EAAE,OAAO;CAC/C,WAAW,EAAE,QAAQ;CACrB,SAAS,EAAE,WAAW,UAAU,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,SAAS,CAAC,CAAC,UAAU,MAAM,CAAC,QAAQ,EAAE,CAAC;CAC9F,OAAO,EAAE,WAAW,UAAU,EAAE,MAAM,sBAAsB,CAAC,UAAU,MAAM,CAAC,QAAQ,EAAE,CAAC;CACzF,CAAC;AAKF,MAAa,oBAAgD,EAAE,MAAM;CACpE;CACA;CACA;CACA,CAAC"}