@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

package/src/content/link.ts

@@ -0,0 +1,154 @@
+import { z } from "zod/mini"
+
+import {
+	EmptyDocumentLinkValueLegacySchema,
+	EmptyImageLinkValueLegacySchema,
+	FilledDocumentLinkValueLegacySchema,
+	FilledFileLinkValueLegacySchema,
+	FilledImageLinkValueLegacySchema,
+	EmptyMediaLinkValueLegacySchema,
+	FilledExternalLinkValueLegacySchema,
+	EmptyExternalLinkValueLegacySchema,
+	AnyLinkLegacySchema,
+	LinkType,
+	EmptyFileLinkValueLegacySchema,
+} from "./legacy/link"
+
+// Image
+const FilledImageLinkValueContentSchema = z.extend(FilledImageLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+const EmptyImageLinkValueContentSchema = z.extend(EmptyImageLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Image),
+})
+
+// File
+const FilledFileLinkValueContentSchema = z.extend(FilledFileLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+const EmptyFileLinkValueContentSchema = z.extend(EmptyFileLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.File),
+})
+
+// Media
+const EmptyMediaLinkValueContentSchema = z.extend(EmptyMediaLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Media),
+})
+
+// Document
+const FilledDocumentLinkValueContentSchema = z.extend(FilledDocumentLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+const EmptyDocumentLinkValueContentSchema = z.extend(EmptyDocumentLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.Document),
+})
+
+// External
+const FilledExternalLinkValueContentSchema = z.extend(FilledExternalLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+const EmptyExternalLinkValueContentSchema = z.extend(EmptyExternalLinkValueLegacySchema, {
+	__TYPE__: z.literal(LinkType.External),
+})
+
+// Any
+const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {
+	__TYPE__: z.literal(LinkType.Any),
+})
+
+// All
+
+// Used by content/richText
+export const FilledLinkValueContentSchema: z.ZodMiniType<FilledLinkValueContent> = z.union([
+	FilledImageLinkValueContentSchema,
+	FilledFileLinkValueContentSchema,
+	FilledDocumentLinkValueContentSchema,
+	FilledExternalLinkValueContentSchema,
+])
+
+// Used by content/legacy/link
+type FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>
+type FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>
+type FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>
+type FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>
+export type FilledLinkValueContent =
+	| FilledImageLinkValueContent
+	| FilledFileLinkValueContent
+	| FilledDocumentLinkValueContent
+	| FilledExternalLinkValueContent
+
+const EmptyLinkValueContentSchema: z.ZodMiniType<EmptyLinkValueContent> = z.union([
+	EmptyImageLinkValueContentSchema,
+	EmptyFileLinkValueContentSchema,
+	EmptyMediaLinkValueContentSchema,
+	EmptyDocumentLinkValueContentSchema,
+	EmptyExternalLinkValueContentSchema,
+	AnyLinkValueContentSchema,
+])
+
+// Used by content/codec/link
+type EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>
+type EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>
+type EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>
+type EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>
+type EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>
+type AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>
+export type EmptyLinkValueContent =
+	| EmptyImageLinkValueContent
+	| EmptyFileLinkValueContent
+	| EmptyMediaLinkValueContent
+	| EmptyDocumentLinkValueContent
+	| EmptyExternalLinkValueContent
+	| AnyLinkValueContent
+
+const LinkValueContentSchema: z.ZodMiniType<LinkValueContent> = z.union([
+	FilledLinkValueContentSchema,
+	EmptyLinkValueContentSchema,
+])
+
+// Used by content/codec/link
+export type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent
+
+// Content
+export const LinkContentType = "LinkContent" as const
+
+export const LinkContentSchema = z.object({
+	__TYPE__: z.literal(LinkContentType),
+	key: z.transform((value) => z.uuidv4().safeParse(value).data || crypto.randomUUID()),
+	// We cannot use z.extend here because we're working with unions.
+	// z.intersection wouldn't work also for the same reason.
+	value: z.pipe(
+		z.pipe(
+			z.pipe(
+				z.record(z.string(), z.unknown()),
+				z.transform(
+					({
+						text,
+						variant,
+						...value
+					}): {
+						text?: unknown
+						variant?: unknown
+						value: Record<string, unknown>
+					} => ({ text, variant, value }),
+				),
+			),
+			z.object({
+				text: z.optional(z.string()),
+				variant: z.optional(z.string()),
+				value: LinkValueContentSchema as z.ZodMiniType<LinkValueContent, Record<string, unknown>>,
+			}),
+		),
+		z.transform(({ text, variant, value }) => ({
+			...(text ? { text } : {}),
+			...(variant ? { variant } : {}),
+			...value,
+		})),
+	),
+})
+
+export type LinkContent = z.infer<typeof LinkContentSchema>

package/src/content/nestable.ts

@@ -0,0 +1,126 @@
+import { z } from "zod/mini"
+
+import type { NestableModel } from "../model/nestable"
+import type { BooleanContent } from "./boolean"
+import { BooleanContentDefaultValue, BooleanContentSchema, BooleanContentType } from "./boolean"
+import type { EmbedContent } from "./embed"
+import { EmbedContentSchema, EmbedContentType } from "./embed"
+import type { EmptyContent } from "./empty"
+import { EmptyContentSchema, EmptyContentType } from "./empty"
+import type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+} from "./field"
+import {
+	ColorContentSchema,
+	DateContentSchema,
+	FieldContentType,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentDefaultValue,
+	SelectContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+} from "./field"
+import type { GeoPointContent } from "./geopoint"
+import { GeoPointContentSchema, GeoPointContentType } from "./geopoint"
+import type { ImageContent } from "./image"
+import { ImageContentSchema, ImageContentType } from "./image"
+import type { IntegrationFieldContent } from "./integrationField"
+import { IntegrationFieldContentSchema, IntegrationFieldContentType } from "./integrationField"
+import type { LinkContent } from "./link"
+import { LinkContentSchema, LinkContentType } from "./link"
+import type { RepeatableContent } from "./repeatable"
+import { RepeatableContentSchema, RepeatableContentType } from "./repeatable"
+import type { RichTextContent } from "./richText"
+import { RichTextContentSchema, RichTextContentType } from "./richText"
+import type { SeparatorContent } from "./separator"
+import { SeparatorContentSchema, SeparatorContentType } from "./separator"
+import type { TableContent } from "./table"
+import { TableContentSchema, TableContentType } from "./table"
+
+export const NestableContentSchema: z.ZodMiniType<NestableContent> = z.union([
+	EmptyContentSchema,
+	BooleanContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	EmbedContentSchema,
+	GeoPointContentSchema,
+	ImageContentSchema,
+	IntegrationFieldContentSchema,
+	LinkContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	RepeatableContentSchema,
+	RichTextContentSchema,
+	SelectContentSchema,
+	SeparatorContentSchema,
+	TableContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+])
+
+export type NestableContent =
+	| EmptyContent
+	| BooleanContent
+	| ColorContent
+	| DateContent
+	| EmbedContent
+	| GeoPointContent
+	| ImageContent
+	| IntegrationFieldContent
+	| LinkContent
+	| NumberContent
+	| RangeContent
+	| RepeatableContent
+	| RichTextContent
+	| SelectContent
+	| SeparatorContent
+	| TableContent
+	| TextContent
+	| TimestampContent
+
+const NestableContentTypes = [
+	EmptyContentType,
+	BooleanContentType,
+	EmbedContentType,
+	FieldContentType,
+	GeoPointContentType,
+	ImageContentType,
+	IntegrationFieldContentType,
+	LinkContentType,
+	RepeatableContentType,
+	RichTextContentType,
+	SeparatorContentType,
+	TableContentType,
+]
+type NestableContentType = (typeof NestableContentTypes)[number]
+
+/** @internal */
+export function isNestableContent(content: {
+	__TYPE__: string
+}): content is { __TYPE__: NestableContentType } {
+	return (NestableContentTypes as string[]).includes(content.__TYPE__)
+}
+
+/**
+ * Returns the default value for a nestable widget based on its configuration.
+ * Currently only Boolean and Select fields have default values.
+ */
+export const NestableContentDefaultValue = (
+	widgetDef: NestableModel,
+): NestableContent | undefined => {
+	switch (widgetDef.type) {
+		case "Boolean":
+			return BooleanContentDefaultValue(widgetDef)
+		case "Select":
+			return SelectContentDefaultValue(widgetDef)
+		default:
+			return undefined
+	}
+}

package/src/content/repeatable.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/mini"
+
+import { LinkContentSchema, LinkContentType } from "./link"
+
+export const RepeatableContentType = "RepeatableContent" as const
+
+export const RepeatableContentSchema = z.object({
+	__TYPE__: z.literal(RepeatableContentType),
+	type: z.literal("Link"),
+	value: z.array(LinkContentSchema),
+})
+
+export type RepeatableContent = z.infer<typeof RepeatableContentSchema>
+
+const RepeatableContentTypes = [LinkContentType]
+type RepeatableContentType = (typeof RepeatableContentTypes)[number]
+export function isRepeatableContentValue(content: {
+	__TYPE__: string
+}): content is { __TYPE__: RepeatableContentType } {
+	return (RepeatableContentTypes as string[]).includes(content.__TYPE__)
+}

package/src/content/richText.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/mini"
+
+import { EmbedContentSchema } from "./embed"
+import { ImageViewContentSchema } from "./image"
+import {
+	getEmbedBlockSchema,
+	getImageBlockSchema,
+	getSpanSchema,
+	getTextBlockSchema,
+} from "./legacy/richText"
+import type { Span } from "./legacy/richText"
+import type { FilledLinkValueContent } from "./link"
+import { FilledLinkValueContentSchema } from "./link"
+
+// Spans
+export type RichTextContentSpan = Span<FilledLinkValueContent>
+
+export const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(
+	FilledLinkValueContentSchema,
+)
+
+// Blocks
+const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)
+type TextBlockValue = z.infer<typeof TextBlockValueSchema>
+
+const ImageBlockValueSchema = getImageBlockSchema(
+	ImageViewContentSchema,
+	FilledLinkValueContentSchema,
+)
+type ImageBlockValue = z.infer<typeof ImageBlockValueSchema>
+
+const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)
+type EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>
+
+export const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([
+	TextBlockValueSchema,
+	ImageBlockValueSchema,
+	EmbedBlockValueSchema,
+])
+
+// Used by content/codec/richText
+export type RichTextContentBlock = TextBlockValue | ImageBlockValue | EmbedBlockValue
+
+export const RichTextContentType = "StructuredTextContent" as const
+
+export type RichTextContent = {
+	__TYPE__: typeof RichTextContentType
+	value: RichTextContentBlock[]
+}
+
+export const RichTextContentSchema: z.ZodMiniType<RichTextContent> = z.object({
+	__TYPE__: z.literal(RichTextContentType),
+	value: z.array(RichTextContentBlockSchema),
+})

package/src/content/separator.ts

@@ -0,0 +1,9 @@
+import { z } from "zod/mini"
+
+export const SeparatorContentType = "SeparatorContent" as const
+
+export const SeparatorContentSchema = z.object({
+	__TYPE__: z.literal(SeparatorContentType),
+})
+
+export type SeparatorContent = z.infer<typeof SeparatorContentSchema>

package/src/content/slice.ts

@@ -0,0 +1,41 @@
+import { z } from "zod/mini"
+
+import { GroupItemContentSchema, NestableAndGroupContentSchema } from "./group"
+import { NestableContentSchema } from "./nestable"
+
+// Legacy (before 2020)
+export const LegacySliceContentSchema = NestableAndGroupContentSchema
+
+export type LegacySliceContent = z.infer<typeof LegacySliceContentSchema>
+
+// Composite (2020 to 2021)
+export const CompositeSliceContentType = "CompositeSliceContent" as const
+
+export const CompositeSliceContentSchema = z.object({
+	__TYPE__: z.literal(CompositeSliceContentType),
+	nonRepeat: z.record(z.string(), NestableContentSchema),
+	repeat: z.array(GroupItemContentSchema),
+})
+
+export type CompositeSliceContent = z.infer<typeof CompositeSliceContentSchema>
+
+// Shared (2021 to present)
+export const SharedSliceContentType = "SharedSliceContent" as const
+
+export const SharedSliceContentSchema = z.object({
+	__TYPE__: z.literal(SharedSliceContentType),
+	variation: z.string(),
+	primary: z.record(z.string(), NestableAndGroupContentSchema),
+	items: z.array(GroupItemContentSchema),
+})
+
+export type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>
+
+// All
+export const SliceContentSchema: z.ZodMiniType<SliceContent> = z.union([
+	LegacySliceContentSchema,
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+])
+
+export type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent

package/src/content/slices.ts

@@ -0,0 +1,57 @@
+import { z } from "zod/mini"
+
+import {
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+	LegacySliceContentSchema,
+	SliceContentSchema,
+} from "./slice"
+
+// Item
+const getSliceItemContentSchema = <
+	TWidgetSchema extends
+		| typeof LegacySliceContentSchema
+		| typeof CompositeSliceContentSchema
+		| typeof SharedSliceContentSchema
+		| typeof SliceContentSchema,
+>(
+	widgetSchema: TWidgetSchema,
+) => {
+	return z.object({
+		key: z.string(),
+		name: z.string(),
+		maybeLabel: z.optional(z.string()),
+		widget: widgetSchema,
+	})
+}
+
+export const LegacySliceItemContentSchema = getSliceItemContentSchema(LegacySliceContentSchema)
+
+export type LegacySliceItemContent = z.infer<typeof LegacySliceItemContentSchema>
+
+export const CompositeSliceItemContentSchema = getSliceItemContentSchema(
+	CompositeSliceContentSchema,
+)
+
+export type CompositeSliceItemContent = z.infer<typeof CompositeSliceItemContentSchema>
+
+export const SharedSliceItemContentSchema = getSliceItemContentSchema(SharedSliceContentSchema)
+
+export type SharedSliceItemContent = z.infer<typeof SharedSliceItemContentSchema>
+
+// All
+export const SliceItemContentSchema = getSliceItemContentSchema(SliceContentSchema)
+
+export type SliceItemContent = z.infer<typeof SliceItemContentSchema>
+
+// Slices
+
+// Typo (missing `s`) is legacy...
+export const SlicesContentType = "SliceContentType" as const
+
+export const SlicesContentSchema = z.object({
+	__TYPE__: z.literal(SlicesContentType),
+	value: z.array(SliceItemContentSchema),
+})
+
+export type SlicesContent = z.infer<typeof SlicesContentSchema>

package/src/content/table.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini"
+
+import { getTableRowSchema } from "./legacy/table"
+import { RichTextContentSchema } from "./richText"
+
+export const TableContentType = "TableContent" as const
+
+// Table
+export const TableContentSchema = z.object({
+	__TYPE__: z.literal(TableContentType),
+	content: z.array(getTableRowSchema(RichTextContentSchema)),
+})
+
+export type TableContent = z.infer<typeof TableContentSchema>

package/src/content/uid.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const UIDContentType = "UIDContent" as const
+
+export const UIDContentSchema = z.object({
+	__TYPE__: z.literal(UIDContentType),
+	value: z.string(),
+})
+
+export type UIDContent = z.infer<typeof UIDContentSchema>

package/src/content/widget.ts

@@ -0,0 +1,21 @@
+import { z } from "zod/mini"
+
+import type { GroupContent } from "./group"
+import { GroupContentSchema } from "./group"
+import type { NestableContent } from "./nestable"
+import { NestableContentSchema } from "./nestable"
+import type { SlicesContent } from "./slices"
+import { SlicesContentSchema } from "./slices"
+import type { UIDContent } from "./uid"
+import { UIDContentSchema } from "./uid"
+
+export const WidgetContentSchema: z.ZodMiniType<WidgetContent> = z.union([
+	GroupContentSchema,
+	NestableContentSchema,
+	UIDContentSchema,
+	SlicesContentSchema,
+])
+
+export type WidgetContent = GroupContent | NestableContent | UIDContent | SlicesContent
+
+export type ContentType = WidgetContent["__TYPE__"]

package/src/content/{fields/withDefaultValues.ts → withDefaultValues.ts}

@@ -1,35 +1,29 @@
-import {
-	type NestableWidget,
-	type SlicePrimaryWidget,
-	Group,
-	GroupFieldType,
-} from "../../customtypes"
-import {
-	GroupContent,
-	GroupContentDefaultValue,
-	GroupContentType,
-	groupContentWithDefaultValues,
-	isGroupContent,
-} from "./GroupContent"
-import type { NestableContent } from "./nestable"
+import type { GroupModel, NestedGroupModel } from "../model/group"
+import type { NestableModel } from "../model/nestable"
+import { GroupContentType, groupContentWithDefaultValues, GroupContentSchema } from "./group"
+import type { GroupContent } from "./group"
 import { NestableContentDefaultValue } from "./nestable"
-import type { SlicePrimaryContent } from "./slices/Slice/SlicePrimaryContent"
+import type { NestableContent } from "./nestable"
 
+/**
+ * Applies default values to slice primary content (non-repeat zone) based on the model configuration.
+ * For each widget in the customType that has no corresponding content, this will add the default value.
+ */
 export function withDefaultSlicePrimaryContentValues(
-	customType: Record<string, SlicePrimaryWidget>,
-	content: Partial<Record<string, SlicePrimaryContent>>,
-): Record<string, SlicePrimaryContent> {
-	const updatedContent = content as Record<string, SlicePrimaryContent>
+	customType: Record<string, NestableModel | NestedGroupModel>,
+	content: Partial<Record<string, NestableContent | GroupContent>>,
+): Record<string, NestableContent | GroupContent> {
+	const updatedContent = content as Record<string, NestableContent | GroupContent>
 
 	for (const [widgetKey, widgetDef] of Object.entries(customType)) {
 		const widgetContent = content[widgetKey]
 
 		if (widgetContent === undefined) {
-			if (widgetDef.type === GroupFieldType) {
-				updatedContent[widgetKey] = groupContentWithDefaultValues(
-					widgetDef,
-					GroupContentDefaultValue,
-				)
+			if (widgetDef.type === "Group") {
+				updatedContent[widgetKey] = groupContentWithDefaultValues(widgetDef, {
+					__TYPE__: GroupContentType,
+					value: [],
+				})
 			} else {
 				const defaultValue = NestableContentDefaultValue(widgetDef)
 
@@ -41,19 +35,21 @@ export function withDefaultSlicePrimaryContentValues(
 			continue
 		}
 
-		if (widgetDef.type === GroupFieldType && isGroupContent(widgetContent)) {
-			updatedContent[widgetKey] = groupContentWithDefaultValues(
-				widgetDef,
-				widgetContent,
-			)
+		const maybeGroupContent = GroupContentSchema.safeParse(widgetContent)
+		if (widgetDef.type === "Group" && maybeGroupContent.success) {
+			updatedContent[widgetKey] = groupContentWithDefaultValues(widgetDef, maybeGroupContent.data)
 		}
 	}
 
 	return updatedContent
 }
 
+/**
+ * Applies default values to nestable content based on the model configuration.
+ * For each widget in the customType that has no corresponding content, this will add the default value.
+ */
 export function withDefaultNestableContentValues(
-	customType: Record<string, NestableWidget>,
+	customType: Record<string, NestableModel>,
 	content: Record<string, NestableContent>,
 ): Record<string, NestableContent> {
 	return Object.entries(customType).reduce<Record<string, NestableContent>>(
@@ -64,7 +60,7 @@ export function withDefaultNestableContentValues(
 					? {
 							...updatedContent,
 							[widgetKey]: defaultValue,
-					  }
+						}
 					: updatedContent
 			}
 
@@ -74,17 +70,19 @@ export function withDefaultNestableContentValues(
 	)
 }
 
+/**
+ * Applies default values to repeatable content items (like group items or slice repeat zones).
+ * For each item, it ensures all required fields have values based on the model configuration.
+ */
 export function repeatableContentWithDefaultNestableContentValues<
 	T extends {
 		value: [string, GroupContent | NestableContent][]
 	},
->(fields: Record<string, Group | NestableWidget>, content: T[]): T[] {
+>(fields: Record<string, GroupModel | NestableModel>, content: T[]): T[] {
 	const groupKeys = Object.entries(fields)
 	return content.map((contentItem) => {
 		return groupKeys.reduce((updatedContentItem, [key, fieldDef]) => {
-			const maybeContentItemValue = contentItem.value.find(
-				([_key]) => _key === key,
-			)
+			const maybeContentItemValue = contentItem.value.find(([_key]) => _key === key)
 
 			if (fieldDef.type === "Group") {
 				const defaultValue = groupContentWithDefaultValues(
@@ -106,10 +104,7 @@ export function repeatableContentWithDefaultNestableContentValues<
 				const defaultValue = NestableContentDefaultValue(fieldDef)
 				return {
 					...updatedContentItem,
-					value: [
-						...updatedContentItem.value,
-						...(defaultValue ? [[key, defaultValue]] : []),
-					],
+					value: [...updatedContentItem.value, ...(defaultValue ? [[key, defaultValue]] : [])],
 				}
 			}
 

package/src/helpers/contentPath.ts

@@ -0,0 +1,35 @@
+export type Part = {
+	type:
+		| "CustomType"
+		| "Widget"
+		| "SharedSlice"
+		| "Slice"
+		| "LegacySlice"
+		| "GroupItem"
+		| "primary"
+		| "items"
+		| "RepeatableItem"
+	key: string
+}
+
+export type Path = ReadonlyArray<Part>
+
+const PATH_SEPARATOR = "::"
+
+export function serialize(path: Path): string {
+	return path.map((part) => part.key).join(PATH_SEPARATOR)
+}
+
+export function current(path: Path): Part | undefined {
+	return path[path.length - 1]
+}
+
+export function append(path: string, strElement: string): string {
+	return path + PATH_SEPARATOR + strElement
+}
+
+export function make(...entries: (Pick<Part, "type"> & Partial<Pick<Part, "key">>)[]): Path {
+	return entries.reduce<Path>((acc, { key, type }) => {
+		return key ? acc.concat({ key, type }) : acc
+	}, [])
+}