@prismicio/types-internal 3.17.0 → 4.0.0-canary.72def6d

package/src/model/separator.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/mini"
+
+const SeparatorConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const SeparatorModelSchema = z.object({
+	type: z.literal("Separator"),
+	config: z.optional(SeparatorConfigSchema),
+})
+
+export type SeparatorModel = z.infer<typeof SeparatorModelSchema>

package/src/model/slice.ts

@@ -0,0 +1,94 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { GroupModelSchema, NestedGroupModelSchema } from "./group"
+import { NestableModelSchema } from "./nestable"
+
+// Simple (before 2020)
+export const LegacySliceModelSchema = z.union([NestableModelSchema, NestedGroupModelSchema])
+
+export type LegacySliceModel = z.infer<typeof LegacySliceModelSchema>
+
+// Composite (2020 to 2021)
+export const CompositeSliceType = "Slice" as const
+
+const CompositeSliceConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const CompositeSliceModelSchema = z.object({
+	type: z.literal(CompositeSliceType),
+	fieldset: z.nullish(z.string()),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	display: z.optional(z.string()),
+	"non-repeat": z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	repeat: z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	config: z.optional(CompositeSliceConfigSchema),
+})
+
+export type CompositeSliceModel = z.infer<typeof CompositeSliceModelSchema>
+
+// Shared (2021 to present)
+export const SharedSliceType = "SharedSlice" as const
+
+const IMAGE_PLACEHOLDER_URL =
+	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
+
+export const VariationSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	imageUrl: z._default(z.string(), IMAGE_PLACEHOLDER_URL),
+	docURL: z.string(),
+	version: z.string(),
+	display: z.optional(z.string()),
+	primary: z.optional(z.record(z.string(), z.union([NestableModelSchema, GroupModelSchema]))),
+	items: z.optional(z.record(z.string(), NestableModelSchema)),
+})
+
+export type Variation = z.infer<typeof VariationSchema>
+
+export const SharedSliceModelSchema = z.object({
+	id: z.string(),
+	type: z.literal(SharedSliceType),
+	name: z.string(),
+	variations: z.array(VariationSchema),
+	description: z.optional(z.string()),
+	legacyPaths: z.optional(z.record(z.string(), z.string())),
+})
+
+export type SharedSliceModel = z.infer<typeof SharedSliceModelSchema>
+
+export const SharedSliceRefModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+})
+
+export type SharedSliceRefModel = z.infer<typeof SharedSliceRefModelSchema>
+
+// All
+
+// Used when slices reference SharedSlice by ref (not full definition)
+export const DynamicSliceModelSchema = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceRefModelSchema,
+])
+
+export type DynamicSliceModel = z.infer<typeof DynamicSliceModelSchema>
+
+// Used when slices include full SharedSlice definition
+export const StaticSliceModelSchema = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceModelSchema,
+])
+
+export type StaticSliceModel = z.infer<typeof StaticSliceModelSchema>
+
+export const SlicesTypesModelSchema = z.union([
+	z.literal(CompositeSliceType),
+	z.literal(SharedSliceType),
+])
+
+export type SlicesTypesModel = z.infer<typeof SlicesTypesModelSchema>

package/src/model/slices.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { StaticSliceModelSchema, DynamicSliceModelSchema } from "./slice"
+
+export const LegacySlicesFieldType = "Choice"
+export const SlicesFieldType = "Slices"
+
+// Label configuration for slices
+const SlicesLabelSchema = z.object({
+	name: z.string(),
+	display: z.optional(z.string()),
+})
+
+export const SlicesLabelsSchema = z.union([
+	z.record(z.string(), z.array(SlicesLabelSchema)),
+	z.null(),
+])
+
+// Config
+const getSlicesConfigSchema = <
+	TSliceSchema extends typeof StaticSliceModelSchema | typeof DynamicSliceModelSchema,
+>(
+	sliceSchema: TSliceSchema,
+) =>
+	z.object({
+		label: z.nullish(z.string()),
+		labels: z.optional(SlicesLabelsSchema),
+		choices: z.optional(z.record(WidgetKeySchema, sliceSchema)),
+	})
+
+const StaticSlicesConfigSchema = getSlicesConfigSchema(StaticSliceModelSchema)
+
+const DynamicSlicesConfigSchema = getSlicesConfigSchema(DynamicSliceModelSchema)
+
+// Model
+const getSlicesSchema = <
+	TConfig extends typeof StaticSlicesConfigSchema | typeof DynamicSlicesConfigSchema,
+>(
+	configSchema: TConfig,
+) =>
+	z.object({
+		type: z.union([z.literal(SlicesFieldType), z.literal(LegacySlicesFieldType)]),
+		fieldset: z.nullish(z.string()),
+		config: z.optional(configSchema),
+	})
+
+export const StaticSlicesModelSchema = getSlicesSchema(StaticSlicesConfigSchema)
+
+export type StaticSlicesModel = z.infer<typeof StaticSlicesModelSchema>
+
+export const DynamicSlicesModelSchema = getSlicesSchema(DynamicSlicesConfigSchema)
+
+export type DynamicSlicesModel = z.infer<typeof DynamicSlicesModelSchema>

package/src/model/table.ts

@@ -0,0 +1,20 @@
+import { z } from "zod/mini"
+
+const TableConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const TableModelSchema = z.object({
+	type: z.literal("Table"),
+	config: z.optional(TableConfigSchema),
+})
+
+export type TableModel = z.infer<typeof TableModelSchema>
+
+// TableCell configuration constant (used for cell rich text configuration)
+export const TableCell = {
+	type: "StructuredText" as const,
+	config: {
+		multi: ["paragraph", "strong", "em", "hyperlink"].join(","),
+	},
+}

package/src/model/text.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const TextConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+})
+
+export const TextModelSchema = z.object({
+	type: z.literal("Text"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(TextConfigSchema),
+})
+
+export type TextModel = z.infer<typeof TextModelSchema>

package/src/model/timestamp.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const TimestampConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default: z.optional(z.string()),
+})
+
+export const TimestampModelSchema = z.object({
+	type: z.literal("Timestamp"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(TimestampConfigSchema),
+})
+
+export type TimestampModel = z.infer<typeof TimestampModelSchema>

package/src/model/uid.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const UIDConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+})
+
+export const UIDModelSchema = z.object({
+	type: z.literal("UID"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(UIDConfigSchema),
+})
+
+export type UIDModel = z.infer<typeof UIDModelSchema>

package/src/model/widget.ts

@@ -0,0 +1,52 @@
+import { z } from "zod/mini"
+
+import { GroupModelSchema } from "./group"
+import { NestableModelSchema } from "./nestable"
+import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./slices"
+import { UIDModelSchema } from "./uid"
+
+// StaticWidget = UID | Nestable | Group | StaticSlices
+export const StaticWidgetModelSchema = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	StaticSlicesModelSchema,
+])
+
+export type StaticWidgetModel = z.infer<typeof StaticWidgetModelSchema>
+
+// DynamicWidget = UID | Nestable | Group | DynamicSlices
+export const DynamicWidgetModelSchema = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	DynamicSlicesModelSchema,
+])
+
+export type DynamicWidgetModel = z.infer<typeof DynamicWidgetModelSchema>
+
+// FieldType - all possible field type strings
+export const FieldTypeSchema = z.enum([
+	"Color",
+	"Boolean",
+	"Number",
+	"Embed",
+	"GeoPoint",
+	"Date",
+	"Range",
+	"StructuredText",
+	"Select",
+	"Separator",
+	"Table",
+	"Text",
+	"Timestamp",
+	"Link",
+	"Image",
+	"IntegrationFields",
+	"UID",
+	"Group",
+	"Slices",
+	"Choice",
+])
+
+export type FieldType = z.infer<typeof FieldTypeSchema>

package/src/zod4.ts

@@ -0,0 +1,153 @@
+// Common
+import { AssetSchema } from "./common/asset"
+import { EmbedSchema } from "./common/embed"
+import { HexaColorCodeSchema } from "./common/hexaColorCode"
+import { NonEmptyStringSchema } from "./common/nonEmptyString"
+import { WidgetKeySchema } from "./common/widgetKey"
+// Content
+import { BooleanContentSchema } from "./content/boolean"
+import { DocumentContentSchema } from "./content/document"
+import { EmbedContentSchema } from "./content/embed"
+import { EmptyContentSchema } from "./content/empty"
+import {
+	ColorContentSchema,
+	DateContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+	FieldContentSchema,
+} from "./content/field"
+import { GeoPointContentSchema } from "./content/geopoint"
+import { GroupContentSchema, GroupItemContentSchema } from "./content/group"
+import { ImageContentSchema } from "./content/image"
+import { IntegrationFieldContentSchema } from "./content/integrationField"
+import { LinkContentSchema } from "./content/link"
+import { NestableContentSchema } from "./content/nestable"
+import { RepeatableContentSchema } from "./content/repeatable"
+import { RichTextContentSchema } from "./content/richText"
+import { SeparatorContentSchema } from "./content/separator"
+import {
+	CompositeSliceContentSchema,
+	SimpleSliceContentSchema,
+	SharedSliceContentSchema,
+	SliceContentSchema,
+} from "./content/slice"
+import { SliceItemContentSchema, SlicesContentSchema } from "./content/slices"
+import { TableContentSchema } from "./content/table"
+import { UIDContentSchema } from "./content/uid"
+import { WidgetContentSchema } from "./content/widget"
+// Model
+import { BooleanModelSchema } from "./model/boolean"
+import { ColorModelSchema } from "./model/color"
+import { StaticCustomTypeModelSchema, CustomTypeModelSchema } from "./model/customType"
+import { DateModelSchema } from "./model/date"
+import { EmbedModelSchema } from "./model/embed"
+import { GeoPointModelSchema } from "./model/geopoint"
+import { GroupModelSchema, NestedGroupModelSchema } from "./model/group"
+import { ImageModelSchema } from "./model/image"
+import { IntegrationFieldModelSchema } from "./model/integrationField"
+import { LinkModelSchema } from "./model/link"
+import { NestableModelSchema } from "./model/nestable"
+import { NumberModelSchema } from "./model/number"
+import { RangeModelSchema } from "./model/range"
+import { RichTextModelSchema } from "./model/richText"
+import { StaticSectionModelSchema, DynamicSectionModelSchema } from "./model/section"
+import { SelectModelSchema } from "./model/select"
+import { SeparatorModelSchema } from "./model/separator"
+import {
+	LegacySliceModelSchema,
+	CompositeSliceModelSchema,
+	SharedSliceModelSchema,
+	SharedSliceRefModelSchema,
+	StaticSliceModelSchema,
+	DynamicSliceModelSchema,
+} from "./model/slice"
+import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./model/slices"
+import { TableModelSchema } from "./model/table"
+import { TextModelSchema } from "./model/text"
+import { TimestampModelSchema } from "./model/timestamp"
+import { UIDModelSchema } from "./model/uid"
+import { StaticWidgetModelSchema, DynamicWidgetModelSchema, FieldTypeSchema } from "./model/widget"
+
+// Common
+export const Asset = toZod4(AssetSchema)
+export const Embed = toZod4(EmbedSchema)
+export const HexaColorCode = toZod4(HexaColorCodeSchema)
+export const NonEmptyString = toZod4(NonEmptyStringSchema)
+export const WidgetKey = toZod4(WidgetKeySchema)
+
+// Content
+export const BooleanContent = toZod4(BooleanContentSchema)
+export const ColorContent = toZod4(ColorContentSchema)
+export const DateContent = toZod4(DateContentSchema)
+export const EmptyContent = toZod4(EmptyContentSchema)
+export const GeoPointContent = toZod4(GeoPointContentSchema)
+export const LinkContent = toZod4(LinkContentSchema)
+export const NumberContent = toZod4(NumberContentSchema)
+export const RangeContent = toZod4(RangeContentSchema)
+export const SelectContent = toZod4(SelectContentSchema)
+export const SeparatorContent = toZod4(SeparatorContentSchema)
+export const SharedSliceContent = toZod4(SharedSliceContentSchema)
+export const TextContent = toZod4(TextContentSchema)
+export const TimestampContent = toZod4(TimestampContentSchema)
+export const FieldContent = toZod4(FieldContentSchema)
+export const UIDContent = toZod4(UIDContentSchema)
+export const IntegrationFieldContent = toZod4(IntegrationFieldContentSchema)
+export const EmbedContent = toZod4(EmbedContentSchema)
+export const ImageContent = toZod4(ImageContentSchema)
+export const RichTextContent = toZod4(RichTextContentSchema)
+export const TableContent = toZod4(TableContentSchema)
+export const RepeatableContent = toZod4(RepeatableContentSchema)
+export const NestableContent = toZod4(NestableContentSchema)
+export const GroupContent = toZod4(GroupContentSchema)
+export const GroupItemContent = toZod4(GroupItemContentSchema)
+export const CompositeSliceContent = toZod4(CompositeSliceContentSchema)
+export const SimpleSliceContent = toZod4(SimpleSliceContentSchema)
+export const SliceContent = toZod4(SliceContentSchema)
+export const SliceItemContent = toZod4(SliceItemContentSchema)
+export const SlicesContent = toZod4(SlicesContentSchema)
+export const WidgetContent = toZod4(WidgetContentSchema)
+export const DocumentContent = toZod4(DocumentContentSchema)
+
+// Model
+export const BooleanModel = toZod4(BooleanModelSchema)
+export const ColorModel = toZod4(ColorModelSchema)
+export const DateModel = toZod4(DateModelSchema)
+export const EmbedModel = toZod4(EmbedModelSchema)
+export const GeoPointModel = toZod4(GeoPointModelSchema)
+export const ImageModel = toZod4(ImageModelSchema)
+export const IntegrationFieldModel = toZod4(IntegrationFieldModelSchema)
+export const LinkModel = toZod4(LinkModelSchema)
+export const NestableModel = toZod4(NestableModelSchema)
+export const NumberModel = toZod4(NumberModelSchema)
+export const RangeModel = toZod4(RangeModelSchema)
+export const RichTextModel = toZod4(RichTextModelSchema)
+export const SelectModel = toZod4(SelectModelSchema)
+export const SeparatorModel = toZod4(SeparatorModelSchema)
+export const SharedSliceModel = toZod4(SharedSliceModelSchema)
+export const TableModel = toZod4(TableModelSchema)
+export const TextModel = toZod4(TextModelSchema)
+export const TimestampModel = toZod4(TimestampModelSchema)
+export const UIDModel = toZod4(UIDModelSchema)
+export const GroupModel = toZod4(GroupModelSchema)
+export const NestedGroupModel = toZod4(NestedGroupModelSchema)
+export const SharedSliceRefModel = toZod4(SharedSliceRefModelSchema)
+export const CompositeSliceModel = toZod4(CompositeSliceModelSchema)
+export const LegacySliceModel = toZod4(LegacySliceModelSchema)
+export const DynamicSliceModel = toZod4(DynamicSliceModelSchema)
+export const StaticSliceModel = toZod4(StaticSliceModelSchema)
+export const DynamicSlicesModel = toZod4(DynamicSlicesModelSchema)
+export const StaticSlicesModel = toZod4(StaticSlicesModelSchema)
+export const StaticWidgetModel = toZod4(StaticWidgetModelSchema)
+export const DynamicWidgetModel = toZod4(DynamicWidgetModelSchema)
+export const FieldType = toZod4(FieldTypeSchema)
+export const StaticSectionModel = toZod4(StaticSectionModelSchema)
+export const DynamicSectionModel = toZod4(DynamicSectionModelSchema)
+export const StaticCustomTypeModel = toZod4(StaticCustomTypeModelSchema)
+export const CustomTypeModel = toZod4(CustomTypeModelSchema)
+
+function toZod4<T>(type: T): T {
+	return type
+}

package/lib/common/Asset.d.ts

@@ -1,16 +0,0 @@
-export declare type Asset = {
-    id: string;
-    last_modified: string;
-    kind: "image" | "all";
-    filename?: string;
-    extension?: string;
-    size?: number;
-    origin_url: string;
-    url: string;
-    width?: number;
-    height?: number;
-    notes?: string;
-    credits?: string;
-    alt?: string;
-};
-export declare const getAssetOrThrow: (assets: Record<Asset["id"], Asset | undefined>) => (assetId: Asset["id"]) => Asset;

package/lib/common/Asset.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAssetOrThrow = void 0;
-const getAssetOrThrow = (assets) => (assetId) => {
-    const asset = assets[assetId];
-    if (!asset) {
-        throw new Error(`Missing asset with id '${assetId}'!`);
-    }
-    return asset;
-};
-exports.getAssetOrThrow = getAssetOrThrow;

package/lib/common/Embed.d.ts

@@ -1,15 +0,0 @@
-export declare type Embed = {
-    type: string;
-    version?: string | null;
-    author_name?: string | null;
-    author_url?: string | null;
-    provider_name?: string | null;
-    provider_url?: string | null;
-    cache_age?: string | null;
-    thumbnail_url?: string | null;
-    thumbnail_width?: number | null;
-    thumbnail_height?: number | null;
-    html?: string | null;
-    title?: string | null;
-};
-export declare const getEmbedOrThrow: (embeds: Record<string, Embed | undefined>) => (embedUrl: string) => Embed;

package/lib/common/Embed.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEmbedOrThrow = void 0;
-const getEmbedOrThrow = (embeds) => (embedUrl) => {
-    const embed = embeds[embedUrl];
-    if (!embed)
-        throw new Error(`Missing embed with url '${embedUrl}'`);
-    return embed;
-};
-exports.getEmbedOrThrow = getEmbedOrThrow;

package/lib/common/HexaColorCode.d.ts

@@ -1,4 +0,0 @@
-export declare type HexaColorCode = `#${string}`;
-export declare const HexaColor: {
-    is: (strColor: string) => strColor is `#${string}`;
-};

package/lib/common/HexaColorCode.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HexaColor = void 0;
-const hexaColorCodeRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/;
-exports.HexaColor = {
-    is: (strColor) => hexaColorCodeRegex.test(strColor),
-};

package/lib/common/UUID.d.ts

@@ -1,6 +0,0 @@
-import * as t from "io-ts";
-export interface UUIDBrand {
-    readonly UUID: unique symbol;
-}
-export declare const UUID: t.BrandC<t.StringC, UUIDBrand>;
-export declare type UUID = t.TypeOf<typeof UUID>;

package/lib/common/UUID.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UUID = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const uuid_1 = require("uuid");
-const function_1 = require("../validators/function");
-exports.UUID = (0, function_1.withCustomError)(t.brand(t.string, (s) => (0, uuid_1.validate)(s), "UUID"), () => "The value must be a valid UUID");

package/lib/common/WidgetKey.d.ts

@@ -1,3 +0,0 @@
-import * as t from "io-ts";
-export declare const WidgetKey: t.Type<string, string, unknown>;
-export declare type WidgetKey = t.TypeOf<typeof WidgetKey>;

package/lib/common/WidgetKey.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetKey = void 0;
-const tslib_1 = require("tslib");
-const t = (0, tslib_1.__importStar)(require("io-ts"));
-const function_1 = require("../validators/function");
-const widgetKeyRegex = new RegExp("^[^<>]+$");
-exports.WidgetKey = (0, function_1.refineType)(t.string, "WidgetKey", (s) => s.length === 0 || widgetKeyRegex.test(s));

package/lib/common/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./Asset";
-export * from "./Embed";
-export * from "./WidgetKey";

package/lib/common/index.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./Asset"), exports);
-(0, tslib_1.__exportStar)(require("./Embed"), exports);
-(0, tslib_1.__exportStar)(require("./WidgetKey"), exports);