@prismicio/types-internal 0.1.1 → 0.2.0

package/src/documents/widgets/nestable/index.ts

@@ -0,0 +1,35 @@
+import { BooleanContentType } from "./BooleanContent"
+import { EmbedContentType } from "./EmbedContent"
+import { FieldContentType } from "./FieldContent"
+import { GeoPointContentType } from "./GeoPointContent"
+import { ImageContentType } from "./ImageContent"
+import { IntegrationFieldsContentType } from "./IntegrationFieldsContent"
+import { LinksTypes } from "./Link"
+import { SeparatorContentType } from "./SeparatorContent"
+import { StructuredTextContentType } from "./StructuredTextContent"
+
+export { default as BooleanContent } from "./BooleanContent"
+export { default as EmbedContent } from "./EmbedContent"
+export { default as FieldContent } from "./FieldContent"
+export { type GeoPointContentO, GeoPointContent } from "./GeoPointContent"
+export {
+	type ImageContentO,
+	ImageContent,
+	ImageContentView,
+} from "./ImageContent"
+export { default as IntegrationFieldsContent } from "./IntegrationFieldsContent"
+export * as Links from "./Link"
+export * from "./SeparatorContent"
+export * from "./StructuredTextContent"
+
+export const NestableTypes = {
+	Links: LinksTypes,
+	StructuredText: StructuredTextContentType,
+	Boolean: BooleanContentType,
+	Embed: EmbedContentType,
+	Field: FieldContentType,
+	GeoPoint: GeoPointContentType,
+	Image: ImageContentType,
+	IntegrationFields: IntegrationFieldsContentType,
+	Separator: SeparatorContentType,
+}

package/src/documents/widgets/slices/CompositeSliceContent.ts

@@ -0,0 +1,77 @@
+import { isRight } from "fp-ts/Either"
+import * as O from "fp-ts/Option"
+import * as t from "io-ts"
+
+import type { GroupItemContent } from "../GroupContent"
+import { GroupContent, SimpleWidgetContent } from "../index"
+
+export const CompositeSliceContentType = "CompositeSliceContent"
+export type CompositeSliceContent = {
+	repeat: GroupItemContent[]
+	nonRepeat: { [key: string]: SimpleWidgetContent }
+	__TYPE__: typeof CompositeSliceContentType
+}
+
+const codec = t.exact(
+	t.partial({
+		repeat: t.array(t.unknown),
+		"non-repeat": t.UnknownRecord,
+	}),
+)
+
+export const CompositeSliceContent = {
+	fromJson: (
+		prefixes: Array<string>,
+		key: string,
+		value: unknown,
+		fieldTypes: Map<string, string>,
+		fieldPositions: Map<string, number>,
+	): O.Option<CompositeSliceContent> => {
+		const prefixedRepeatKey = Array.of(prefixes, [key, "repeat"])
+			.flat()
+			.join(".")
+
+		const decodedValue = codec.decode(value)
+		if (isRight(decodedValue)) {
+			const repeatObj = decodedValue.right.repeat
+			const nonRepeatObj = decodedValue.right["non-repeat"] ?? {}
+			const groupItemsContentsRepeat = GroupContent.itemsContentsFromJson(
+				prefixedRepeatKey,
+				repeatObj,
+				fieldTypes,
+				fieldPositions,
+			)
+			const sortedFields = Object.entries(nonRepeatObj).sort(([k1], [k2]) => {
+				const p1 =
+					fieldPositions.get(
+						`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`,
+					) ?? 10000
+				const p2 =
+					fieldPositions.get(
+						`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`,
+					) ?? 10000
+				return p1 - p2
+			})
+
+			const nonRepeat = sortedFields.reduce((acc, [k, v]) => {
+				const kp = Array.of(prefixes, [key, "non-repeat", k]).flat().join(".")
+				const kind = fieldTypes.get(kp)
+				if (kind) {
+					const mWidgetContent = SimpleWidgetContent.from(kind, v)
+					if (O.isSome(mWidgetContent)) {
+						acc[k] = mWidgetContent.value
+					}
+				}
+				return acc
+			}, {} as Record<string, SimpleWidgetContent>)
+
+			return O.some({
+				repeat: groupItemsContentsRepeat,
+				nonRepeat,
+				__TYPE__: "CompositeSliceContent",
+			})
+		} else {
+			return O.none
+		}
+	},
+}

package/src/documents/widgets/slices/SharedSliceContent.ts

@@ -0,0 +1,94 @@
+import { map } from "fp-ts/Either"
+import * as O from "fp-ts/Option"
+import * as t from "io-ts"
+import { withFallback } from "io-ts-types"
+
+import type { GroupItemContent } from "../GroupContent"
+import { GroupContent, SimpleWidgetContent } from "../index"
+
+export const SharedSliceContentType = "SharedSliceContent"
+export type SharedSliceContent = {
+	variation: string
+	primary: { [key: string]: SimpleWidgetContent }
+	items: GroupItemContent[]
+	__TYPE__: typeof SharedSliceContentType
+}
+
+const codec = t.exact(
+	t.type({
+		variation: t.string,
+		items: withFallback(t.array(t.unknown), []),
+		primary: withFallback(t.UnknownRecord, {}),
+	}),
+)
+
+export const SharedSliceContent = {
+	fromJson: (
+		prefixes: Array<string>,
+		key: string,
+		value: unknown,
+		fieldTypes: Map<string, string>,
+		fieldPositions: Map<string, number>,
+	): O.Option<SharedSliceContent> => {
+		type SharedSliceContentC = t.TypeOf<typeof codec>
+
+		const r = map((v: SharedSliceContentC) => {
+			const prefixedItemsKey = Array.of(prefixes, [
+				key,
+				"variations",
+				v.variation,
+				"items",
+			])
+				.flat()
+				.join(".")
+			const groupItemsContents = GroupContent.itemsContentsFromJson(
+				prefixedItemsKey,
+				v.items,
+				fieldTypes,
+				fieldPositions,
+			)
+			const sortedFields = Object.entries(v.primary).sort(([k1], [k2]) => {
+				const p1 =
+					fieldPositions.get(
+						`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`,
+					) ?? 10000
+				const p2 =
+					fieldPositions.get(
+						`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`,
+					) ?? 10000
+				return p1 - p2
+			})
+
+			const primary = sortedFields.reduce((acc, [k, w]) => {
+				const kp = Array.of(prefixes, [
+					key,
+					"variations",
+					v.variation,
+					"primary",
+					k,
+				])
+					.flat()
+					.join(".")
+				const kind = fieldTypes.get(kp)
+				if (kind) {
+					const maybeWidgetContent = SimpleWidgetContent.from(kind, w)
+					if (O.isSome(maybeWidgetContent)) {
+						acc[k] = maybeWidgetContent.value
+					}
+				}
+				return acc
+			}, {} as Record<string, SimpleWidgetContent>)
+
+			const result: SharedSliceContent = {
+				variation: v.variation,
+				primary,
+				items: groupItemsContents,
+				__TYPE__: "SharedSliceContent",
+			}
+
+			return result
+		})(codec.decode(value))
+
+		return O.fromEither(r)
+	},
+}

package/src/documents/widgets/slices/SimpleSliceContent.ts

@@ -0,0 +1,4 @@
+import StaticWidgetContent from "../StaticWidgetContent"
+
+export type SimpleSliceContent = StaticWidgetContent
+export const SimpleSliceContent = StaticWidgetContent

package/src/documents/widgets/slices/SliceWidgetContent.ts

@@ -0,0 +1,51 @@
+import * as O from "fp-ts/Option"
+
+import StaticWidgetContent from "../StaticWidgetContent"
+import { CompositeSliceContent } from "./CompositeSliceContent"
+import { SharedSliceContent } from "./SharedSliceContent"
+import type { SimpleSliceContent } from "./SimpleSliceContent"
+
+export type SliceWidgetContent =
+	| SimpleSliceContent
+	| CompositeSliceContent
+	| SharedSliceContent
+export const SliceWidgetContent = {
+	fromJson: (
+		prefixes: Array<string>,
+		key: string,
+		value: unknown,
+		fieldTypes: Map<string, string>,
+		fieldPositions: Map<string, number>,
+	): O.Option<SliceWidgetContent> => {
+		const prefixedKey = Array.of(prefixes, [key]).flat().join(".")
+
+		const fieldType = fieldTypes.get(prefixedKey)
+		if (fieldType === "SharedSlice") {
+			return SharedSliceContent.fromJson(
+				prefixes,
+				key,
+				value,
+				fieldTypes,
+				fieldPositions,
+			)
+		} else if (fieldType === "Slice") {
+			return CompositeSliceContent.fromJson(
+				prefixes,
+				key,
+				value,
+				fieldTypes,
+				fieldPositions,
+			)
+		} else if (fieldType) {
+			return StaticWidgetContent.fromJson(
+				prefixes,
+				key,
+				value,
+				fieldTypes,
+				fieldPositions,
+			)
+		} else {
+			return O.none
+		}
+	},
+}

package/src/documents/widgets/slices/SlicesContent.ts

@@ -0,0 +1,91 @@
+import * as A from "fp-ts/Array"
+import { pipe } from "fp-ts/function"
+import * as O from "fp-ts/Option"
+import * as t from "io-ts"
+
+import { nullable } from "../../../validators/function"
+import { SliceWidgetContent } from "./SliceWidgetContent"
+
+export type SlicesContentItem = {
+	key: string
+	name: string
+	maybeLabel: string | undefined
+	widget: SliceWidgetContent
+}
+
+export const SlicesContentType = "SliceContentType"
+export type SlicesContent = {
+	__TYPE__: typeof SlicesContentType
+	value: SlicesContentItem[]
+}
+const codec = t.exact(
+	t.intersection([
+		t.type({
+			key: t.string,
+			value: t.unknown,
+		}),
+		t.partial({
+			label: nullable(t.string),
+		}),
+	]),
+)
+export const SlicesContent = {
+	itemsCodec: (
+		value: unknown,
+		codecWidget: (n: string, v: unknown) => O.Option<SliceWidgetContent>,
+	): O.Option<SlicesContentItem> => {
+		return pipe(
+			codec.decode(value),
+			O.fromEither,
+			O.chain((r) => {
+				const stopIdx = r.key.indexOf("$")
+				const name = r.key.substring(0, stopIdx > 0 ? stopIdx : undefined)
+				const maybeWidget = codecWidget(name, r.value)
+				return O.map((widget) => {
+					return {
+						key: r.key,
+						name,
+						maybeLabel: r.label ?? undefined,
+						widget: widget,
+					} as SlicesContentItem
+				})(maybeWidget)
+			}),
+		)
+	},
+	fromJson: (
+		key: string,
+		value: unknown,
+		fieldTypes: Map<string, string>,
+		fieldPositions: Map<string, number>,
+	): O.Option<SlicesContent> => {
+		if (fieldTypes.get(key) === "Slices") {
+			const jsItems = O.getOrElse(() => new Array<unknown>())(
+				O.fromEither(t.array(t.unknown).decode(value)),
+			)
+
+			const widgetCodec = (
+				name: string,
+				wValue: unknown,
+			): O.Option<SliceWidgetContent> =>
+				SliceWidgetContent.fromJson(
+					[key],
+					name,
+					wValue,
+					fieldTypes,
+					fieldPositions,
+				)
+
+			return O.some({
+				value: A.compact(
+					jsItems.map((jsItem: unknown) =>
+						SlicesContent.itemsCodec(jsItem, widgetCodec),
+					),
+				),
+				__TYPE__: SlicesContentType,
+			} as const)
+		} else {
+			console.error("fieldTypes.get(key) !== 'Slices'")
+			return O.none
+		}
+	},
+}

package/src/documents/widgets/slices/index.ts

@@ -0,0 +1,5 @@
+export * from "./CompositeSliceContent"
+export * from "./SharedSliceContent"
+export * from "./SimpleSliceContent"
+export * from "./SlicesContent"
+export * from "./SliceWidgetContent"

package/src/index.ts

@@ -1 +1,3 @@
-export * as CustomTypes from './customtypes'
+export * as CustomTypes from "./customtypes"
+export * as Documents from "./documents"
+export * as Validators from "./validators"

package/src/validators/DateFromString.ts

@@ -0,0 +1,17 @@
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+export default new t.Type<Date, string, unknown>(
+	"dateFromString",
+	(u): u is Date => u instanceof Date,
+	(u, c) =>
+		pipe(
+			t.string.validate(u, c),
+			chain((s) => {
+				const d = new Date(s)
+				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
+			}),
+		),
+	(date) => date.toISOString(),
+)

package/src/validators/DateFromStringOrNumber.ts

@@ -0,0 +1,17 @@
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+export default new t.Type<Date, Date, unknown>(
+	"dateFromStringOrNumber",
+	(u): u is Date => u instanceof Date,
+	(u, c) =>
+		pipe(
+			t.union([t.number, t.string]).validate(u, c),
+			chain((s) => {
+				const d = new Date(s)
+				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
+			}),
+		),
+	(date) => date,
+)

package/src/validators/DateFromTsMs.ts

@@ -0,0 +1,17 @@
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+export default new t.Type<Date, number, unknown>(
+	"dateFromTsMs",
+	(u): u is Date => u instanceof Date,
+	(u, c) =>
+		pipe(
+			t.number.validate(u, c),
+			chain((s) => {
+				const d = new Date(s)
+				return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d)
+			}),
+		),
+	(date) => date.getTime(),
+)

package/src/validators/IntFromNumber.ts

@@ -1,24 +1,22 @@
- import * as t from 'io-ts'
- import { pipe } from 'fp-ts/lib/pipeable'
- import { chain } from 'fp-ts/lib/Either'
- 
- export interface IntFromNumberC extends t.Type<t.Int, number, unknown> {}
- 
- /**
-  * A codec that succeeds if a number can be parsed to an integer
-  */
- export const IntFromNumber: IntFromNumberC = new t.Type<t.Int, number, unknown>(
-   'IntFromNumber',
-   t.Int.is,
-   (u, c) =>
-     pipe(
-       t.number.validate(u, c),
-       chain(n => {
-         if(t.Int.is(n)) return t.success(n)
-         else {
-          return t.success(Math.round(n) as t.Int)
-         }
-       })
-     ),
-     t.Int.encode
- )
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+export type IntFromNumberC = t.Type<t.Int, number, unknown>
+
+/** A codec that succeeds if a number can be parsed to an integer */
+export default new t.Type<t.Int, number, unknown>(
+	"IntFromNumber",
+	t.Int.is,
+	(u, c) =>
+		pipe(
+			t.number.validate(u, c),
+			chain((n) => {
+				if (t.Int.is(n)) return t.success(n)
+				else {
+					return t.success(Math.round(n) as t.Int)
+				}
+			}),
+		),
+	t.Int.encode,
+)

package/src/validators/IntFromPixels.ts

@@ -1,31 +1,32 @@
-import * as t from 'io-ts'
-import { pipe } from 'fp-ts/lib/pipeable'
-import { chain } from 'fp-ts/lib/Either'
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
 
-export interface IntFromPixelsC extends t.Type<t.Int, string, unknown> {}
+export type IntFromPixelsC = t.Type<t.Int, string, unknown>
 
 const PixelsRegex = /^([0-9]+)px$/
 /**
- * A codec that succeeds if a string representing pixels (eg: "200px") can be parsed to an integer
+ * A codec that succeeds if a string representing pixels (eg: "200px") can be
+ * parsed to an integer
  */
-export const IntFromPixels: IntFromPixelsC = new t.Type<t.Int, string, unknown>(
-  'IntFromPixels',
-  t.Int.is,
-  (u, c) =>
-    pipe(
-      t.string.validate(u, c),
-      chain(strPixels => {
-        try {
-          const matched = strPixels.match(PixelsRegex)
-          if(!matched) return t.failure(u, c)
-          else {
-            const parsed = parseInt(matched[1]) as t.Int
-            return t.success(parsed)
-          }
-        } catch {
-          return t.failure(u, c)
-        }
-      })
-    ),
-    String
-)
+export default new t.Type<t.Int, string, unknown>(
+	"IntFromPixels",
+	t.Int.is,
+	(u, c) =>
+		pipe(
+			t.string.validate(u, c),
+			chain((strPixels) => {
+				try {
+					const matched = strPixels.match(PixelsRegex)
+					if (!matched) return t.failure(u, c)
+
+					/* eslint-disable  @typescript-eslint/no-non-null-assertion */
+					const parsed = parseInt(matched[1]!) as t.Int
+					return t.success(parsed)
+				} catch {
+					return t.failure(u, c)
+				}
+			}),
+		),
+	String,
+)

package/src/validators/NonEmptyString.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts"
+
+import { refineType } from "./function"
+
+export default refineType(
+	t.string,
+	"nonEmptyString",
+	(s) => s.trim().length > 0,
+)

package/src/validators/NonEmptyStringOrNull.ts

@@ -0,0 +1,22 @@
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import { success, Type } from "io-ts"
+
+import StringOrNull from "./StringOrNull"
+
+export default new Type<string | null, string | null, unknown>(
+	"nonEmptyStringOrNull",
+	(u): u is string => typeof u === "string" || u === null,
+	(u, c) =>
+		pipe(
+			StringOrNull.validate(u, c),
+			chain((s) => {
+				if (typeof s === "string" && s.length > 0) {
+					return success(s)
+				} else {
+					return success(null)
+				}
+			}),
+		),
+	(s) => s,
+)

package/src/validators/NumberOrNull.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts"
+
+import { nullable } from "./function"
+
+export default nullable(t.number)

package/src/validators/StringFromBoolean.ts

@@ -1,21 +1,19 @@
-import * as t from 'io-ts'
-import { pipe } from 'fp-ts/lib/pipeable'
-import { chain } from 'fp-ts/lib/Either'
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
 
-export interface StringFromBooleanC extends t.Type<string, string, unknown> {}
+export type StringFromBooleanC = t.Type<string, string, unknown>
 
-/**
- * A codec that validates a Boolean and convert it as a string
- */
-export const StringFromBoolean: StringFromBooleanC = new t.Type<string, string, unknown>(
-  'StringFromInt',
-  t.string.is,
-  (u, c) =>
-    pipe(
-      t.boolean.validate(u, c),
-      chain(i => {
-        return t.success(i.toString())
-      })
-    ),
-    i => i
-)
+/** A codec that validates a Boolean and convert it as a string */
+export default new t.Type<string, string, unknown>(
+	"StringFromInt",
+	t.string.is,
+	(u, c) =>
+		pipe(
+			t.boolean.validate(u, c),
+			chain((i) => {
+				return t.success(i.toString())
+			}),
+		),
+	(i) => i,
+)

package/src/validators/StringFromNumber.ts

@@ -1,21 +1,19 @@
-import * as t from 'io-ts'
-import { pipe } from 'fp-ts/lib/pipeable'
-import { chain } from 'fp-ts/lib/Either'
+import { chain } from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
 
-export interface StringFromNumberC extends t.Type<string, string, unknown> {}
+export type StringFromNumberC = t.Type<string, string, unknown>
 
-/**
- * A codec that validates a number and convert it as a string
- */
-export const StringFromNumber: StringFromNumberC = new t.Type<string, string, unknown>(
-  'StringFromInt',
-  t.string.is,
-  (u, c) =>
-    pipe(
-      t.number.validate(u, c),
-      chain(i => {
-        return t.success(i.toString())
-      })
-    ),
-    i => i
-)
+/** A codec that validates a number and convert it as a string */
+export default new t.Type<string, string, unknown>(
+	"StringFromInt",
+	t.string.is,
+	(u, c) =>
+		pipe(
+			t.number.validate(u, c),
+			chain((i) => {
+				return t.success(i.toString())
+			}),
+		),
+	(i) => i,
+)

package/src/validators/StringOrNull.ts

@@ -1,3 +1,5 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-export const StringOrNull = t.union([ t.string, t.null, t.undefined ])
+import { nullable } from "./function"
+
+export default nullable(t.string)