@prismicio/types-internal 2.2.0-traverse.alpha-11 → 2.2.0

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/SharedSliceContentEntry.ts

@@ -1,100 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as t from "io-ts"
-
-import { WidgetKey } from "../../../../../../../common"
-import type { NestableWidget } from "../../../../../../../customtypes"
-import { ImportNestable } from "../../../../nestable"
-import { SharedSliceContentErrors } from "./errors"
-
-export type SharedSliceContentEntry = [WidgetKey, ImportNestable]
-/**
- * Represents a single entry in the 'primary' field or a single entry in an item in the 'items' array in the SharedSlice. It is used to build the SharedSliceContent type from entries of the import object.
- *
- * For example, given the following slice:
- * 	{
- *  	"slice_type": "my_slice",
- *  	"variation": "default",
- *      "primary": {
- *      	"slice_text": "abc", // This is one entry
- *          "slice_text2": "def: // This is another entry
- *       },
- *       "items": [
- *       	   {
- *             		"slice_number1": 0, // This is one entry
- *             		"slice_number2": 1	// And this is yet another entry
- *             }
- *       ]
- *  }
- *
- *  The 'primary' object is converted to following entries to be decoded:
- *  [
- *      ["slice_text", "abc"],
- *      ["slice_text2", "def"]
- *  ]
- *  and the first item in the 'items' array is converted to following entries to be decoded:
- *  [
- *    ["slice_number1", 0],
- *    ["slice_number2", 1]
- *  ]
- *
- *  We decode them as separate entries because each of the values might require a different codec as per what is specified in the SharedSlice custom type.
- *  In this way we save on the decoding performance in comparison to a scenario where we would decode the whole content object as a record with a union type decoder for each value.
- *
- *  @param sliceName name of the slice - used for error reporting in order to know which slice is being decoded
- *  @param sliceContentField 'primary' or 'items' - used for error reporting in order to know which field of the slice is being decoded
- *  @param sliceFieldModels models of the fields of the slice from custom type - used to know which codec to use for decoding each value of the object
- */
-export const SharedSliceContentEntry = (
-	sliceName: string,
-	sliceContentField: "primary" | "items",
-	sliceFieldModels: Record<WidgetKey, NestableWidget>,
-) =>
-	new t.Type<SharedSliceContentEntry, SharedSliceContentEntry, unknown>(
-		"SharedSliceContentEntry",
-		(u): u is SharedSliceContentEntry =>
-			t.tuple([WidgetKey, t.unknown]).is(u) && ImportNestable.is(u[1]),
-		(u, c) => {
-			return pipe(
-				t.tuple([WidgetKey, t.unknown]).validate(u, c),
-				E.chain(([key, content]) => {
-					const model: NestableWidget | undefined = sliceFieldModels[key]
-					if (!model) {
-						return t.failure(
-							[key, content],
-							[...c, { key, actual: content, type: t.unknown }],
-							SharedSliceContentErrors.UnknownField(
-								sliceName,
-								sliceContentField,
-								key,
-							),
-						)
-					}
-					const { codec, result } = ImportNestable.decode(model)(content)
-
-					return pipe(
-						result,
-						E.map<ImportNestable, SharedSliceContentEntry>((decodedContent) => [
-							key,
-							decodedContent,
-						]),
-						E.mapLeft(
-							(errors): t.Errors =>
-								errors.map((error) => {
-									const context = [
-										...c,
-										{ key, actual: content, type: codec },
-										...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
-									]
-
-									const updatedError: t.ValidationError = { ...error, context }
-
-									return updatedError
-								}),
-						),
-					)
-				}),
-			)
-		},
-		t.identity,
-	)

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/errors.ts

@@ -1,10 +0,0 @@
-import type { SharedSliceContentField } from "./types"
-
-export const SharedSliceContentErrors = {
-	UnknownField: (
-		sliceName: string,
-		contentField: SharedSliceContentField,
-		fieldName: string,
-	) =>
-		`Unsupported field '${fieldName}'for '${contentField}' content in Shared Slice '${sliceName}'`,
-} as const

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/index.ts

@@ -1,2 +0,0 @@
-export * from "./errors"
-export * from "./SharedSliceContent"

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceContent/types.ts

@@ -1 +0,0 @@
-export type SharedSliceContentField = "primary" | "items"

package/src/utils/io-ts.ts

@@ -1,29 +0,0 @@
-import * as E from "fp-ts/Either"
-import { pipe } from "fp-ts/function"
-import * as RA from "fp-ts/ReadonlyArray"
-import type { Semigroup } from "fp-ts/Semigroup"
-import type { Errors, Validation } from "io-ts"
-
-/*
- * Semigroup simply defines how to concatenate two values of the same type.
- * In this instance, Errors from io-ts are arrays already, so we just need to concatenate them.
- */
-const validationErrorsSemigroup: Semigroup<Errors> = {
-	concat: (a: Errors, b: Errors) => [...a, ...b],
-}
-
-/*
- * This is a helper function to combine multiple io-ts validations into one.
- *  t.array(...) works in the same way - it collects all the errors when decoding an array of values.
- * 	However, it requires you to pass in a single io-ts validator as a parameter, which is not always convenient.
- * 	Sometimes we have arrays of validation results received from function calls that don't have a validator instance.
- */
-export const combineValidationResults = <T>(
-	validationResults: readonly Validation<T>[],
-): Validation<readonly T[]> =>
-	pipe(
-		validationResults,
-		RA.traverse(E.getApplicativeValidation(validationErrorsSemigroup))(
-			(validation) => validation,
-		),
-	)