@prismicio/types-internal 0.1.1 → 0.2.3

package/src/customtypes/CustomType.ts

@@ -1,53 +1,55 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../validators/StringOrNull'
-import { Either, right, left } from 'fp-ts/lib/Either'
-import { withFallback } from 'io-ts-types/lib/withFallback'
-
-import { Format } from './Format'
-import { DynamicWidget } from './widgets/Widget'
-import SharedSlice from './widgets/slices/SharedSlice'
-import { DynamicSlice } from './widgets/slices/Slice'
-import { DynamicSlices } from './widgets/slices/Slices'
-import WidgetTypes from './widgets/WidgetTypes'
-import SlicesTypes from './widgets/slices/SlicesTypes'
-
-import { StaticSection, DynamicSection, sectionReader, Sections } from './Section'
+import { Either, left, right } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+import { withFallback } from "io-ts-types/lib/withFallback"
+
+import { StringOrNull } from "../validators"
+import { Format } from "./Format"
+import {
+	DynamicSection,
+	sectionReader,
+	Sections,
+	StaticSection,
+} from "./Section"
+import type SharedSlice from "./widgets/slices/SharedSlice"
+import type { DynamicSlice } from "./widgets/slices/Slice"
+import type { DynamicSlices } from "./widgets/slices/Slices"
+import SlicesTypes from "./widgets/slices/SlicesTypes"
+import type { DynamicWidget } from "./widgets/Widget"
+import WidgetTypes from "./widgets/WidgetTypes"
 
 class CustomTypeSlicesError extends Error {
-  slices: Array<string>
-  message: string
-
-  constructor(slices: Array<string>) {
-    super()
-    this.slices = slices
-    this.message = this._formatError(slices)
-  }
-
-  _formatError(slicesRefs: Array<string>) {
-    const slicesMsg = slicesRefs.map(ref => `\t - ${ref}`);
-    return (
-`The following slices doesn't exists in your Prismic repository:
-${slicesMsg.join('\n')}
+	slices: Array<string>
+	override message: string
+
+	constructor(slices: Array<string>) {
+		super()
+		this.slices = slices
+		this.message = this._formatError(slices)
+	}
+
+	_formatError(slicesRefs: Array<string>) {
+		const slicesMsg = slicesRefs.map((ref) => `\t - ${ref}`)
+		return `The following slices doesn't exists in your Prismic repository:
+${slicesMsg.join("\n")}
 `
-    )
-  }
+	}
 }
 
 function customTypeReader<F extends Format>(format: F) {
-  return t.exact(
-    t.intersection([
-      t.type({
-        id: t.string,
-        label: StringOrNull,
-        repeatable: withFallback(t.boolean, true),
-        json: t.record(t.string, sectionReader(format)),
-        status: withFallback(t.boolean, true)
-      }),
-      t.partial({
-        hash: t.string
-      })
-    ])
-  )
+	return t.exact(
+		t.intersection([
+			t.type({
+				id: t.string,
+				label: StringOrNull,
+				repeatable: withFallback(t.boolean, true),
+				json: t.record(t.string, sectionReader(format)),
+				status: withFallback(t.boolean, true),
+			}),
+			t.partial({
+				hash: t.string,
+			}),
+		]),
+	)
 }
 
 export const StaticCustomType = customTypeReader(Format.Static)
@@ -57,86 +59,141 @@ export const CustomType = customTypeReader(Format.Dynamic)
 export type CustomType = t.TypeOf<typeof CustomType>
 
 function _retrieveSharedSlicesRef(customType: CustomType): Array<string> {
-  const flattenWidgets: Array<[string, DynamicWidget]> = Object.entries(customType.json)
-    .reduce((acc: Array<[string, DynamicWidget]>, [, section]: [string, DynamicSection]) => {
-      const sectionWidgets: Array<[string, DynamicWidget]> = Object.entries(section)
-      return acc.concat(sectionWidgets);
-    }, [])
-
-  const slicezones = flattenWidgets.filter(([, widget]: [string, DynamicWidget]) => widget.type === WidgetTypes.Slices) as Array<[string, DynamicSlices]>
-
-  const allSharedRefs = slicezones.reduce((acc: Array<string>, [, slicezone]) => {
-    const sharedRefs = Object.entries(slicezone.config && slicezone.config.choices ? slicezone.config.choices : {})
-      .filter(([, slice]: [string, DynamicSlice]) => slice.type === SlicesTypes.SharedSlice)
-      .map(([key]) => key)
-    return acc.concat(sharedRefs);
-  }, []);
-
-  return allSharedRefs
+	const flattenWidgets: Array<[string, DynamicWidget]> = Object.entries(
+		customType.json,
+	).reduce(
+		(
+			acc: Array<[string, DynamicWidget]>,
+			[, section]: [string, DynamicSection],
+		) => {
+			const sectionWidgets: Array<[string, DynamicWidget]> =
+				Object.entries(section)
+			return acc.concat(sectionWidgets)
+		},
+		[],
+	)
+
+	const slicezones = flattenWidgets.filter(
+		([, widget]: [string, DynamicWidget]) => widget.type === WidgetTypes.Slices,
+	) as Array<[string, DynamicSlices]>
+
+	const allSharedRefs = slicezones.reduce(
+		(acc: Array<string>, [, slicezone]) => {
+			const sharedRefs = Object.entries(
+				slicezone.config && slicezone.config.choices
+					? slicezone.config.choices
+					: {},
+			)
+				.filter(
+					([, slice]: [string, DynamicSlice]) =>
+						slice.type === SlicesTypes.SharedSlice,
+				)
+				.map(([key]) => key)
+			return acc.concat(sharedRefs)
+		},
+		[],
+	)
+
+	return allSharedRefs
 }
 
-function _mapSharedSlicesRefs<A>(customType: CustomType): (mapFn: (ref: string) => A) => Array<A> {
-  const refs = _retrieveSharedSlicesRef(customType)
+function _mapSharedSlicesRefs<A>(
+	customType: CustomType,
+): (mapFn: (ref: string) => A) => Array<A> {
+	const refs = _retrieveSharedSlicesRef(customType)
 
-  return function(mapFn: (ref: string) => A): Array<A> {
-    return refs.map(mapFn)
-  }
+	return function (mapFn: (ref: string) => A): Array<A> {
+		return refs.map(mapFn)
+	}
 }
 
-export function toStatic(customType: CustomType, sharedSlices: Map<string, SharedSlice>): StaticCustomType {
-  const json = Object.entries(customType.json)
-    .reduce((acc: { [key: string]: StaticSection }, [sectionKey, dynSection]: [string, DynamicSection]) => {
-      return { ...acc, [sectionKey]: Sections.toStatic(dynSection, sharedSlices) };
-  }, {})
-
-  return { ...customType, json } as StaticCustomType;
+export function toStatic(
+	customType: CustomType,
+	sharedSlices: Map<string, SharedSlice>,
+): StaticCustomType {
+	const json = Object.entries(customType.json).reduce(
+		(
+			acc: { [key: string]: StaticSection },
+			[sectionKey, dynSection]: [string, DynamicSection],
+		) => {
+			return {
+				...acc,
+				[sectionKey]: Sections.toStatic(dynSection, sharedSlices),
+			}
+		},
+		{},
+	)
+
+	return { ...customType, json } as StaticCustomType
 }
 
-export function validateSlices(customType: CustomType, sharedSlices: Map<string, SharedSlice>): Either<CustomTypeSlicesError, CustomType> {
-  const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)((ref: string) => {
-    const slice: SharedSlice | undefined = sharedSlices.get(ref)
-    const isMissing = !Boolean(slice)
-    if(isMissing) return ref
-  }).filter(Boolean) as Array<string>
-
-  if(missingSlices.length > 0) return left(new CustomTypeSlicesError(missingSlices))
-  else return right(customType)
+export function validateSlices(
+	customType: CustomType,
+	sharedSlices: Map<string, SharedSlice>,
+): Either<CustomTypeSlicesError, CustomType> {
+	const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)(
+		(ref: string) => {
+			const slice: SharedSlice | undefined = sharedSlices.get(ref)
+			const isMissing = !slice
+			if (isMissing) return ref
+			return
+		},
+	).filter(Boolean) as Array<string>
+
+	if (missingSlices.length > 0)
+		return left(new CustomTypeSlicesError(missingSlices))
+	else return right(customType)
 }
 
-export function collectWidgets(customType: CustomType, f:((ref: string, widget: DynamicWidget) => DynamicWidget|undefined)): CustomType {
-  const json = Object.entries(customType.json)
-    .reduce((acc, [sectionId, section]: [string, DynamicSection]) => {
-      const updatedSection = Object
-        .entries(section)
-        .reduce((acc, [ref, widget]) => {
-          const updatedWidget = f(ref, widget)
-          if (!!updatedWidget) {
-            return {...acc, [ref]: updatedWidget}
-          }
-          return acc;
-        }, {});
-      return {...acc, [sectionId]: updatedSection};
-    }, {});
-
-  return { ...customType, json };
+export function collectWidgets(
+	customType: CustomType,
+	f: (ref: string, widget: DynamicWidget) => DynamicWidget | undefined,
+): CustomType {
+	const json = Object.entries(customType.json).reduce(
+		(acc, [sectionId, section]: [string, DynamicSection]) => {
+			const updatedSection = Object.entries(section).reduce(
+				(acc, [ref, widget]) => {
+					const updatedWidget = f(ref, widget)
+					if (updatedWidget) {
+						return { ...acc, [ref]: updatedWidget }
+					}
+					return acc
+				},
+				{},
+			)
+			return { ...acc, [sectionId]: updatedSection }
+		},
+		{},
+	)
+
+	return { ...customType, json }
 }
 
-export function filterMissingSharedSlices(customType: CustomType, sharedSlices: Map<string, SharedSlice>): CustomType {
-  return collectWidgets(customType, (_widgetId, widget) => {
-    if (widget.type === WidgetTypes.Slices) {
-      if(!widget.config || !widget.config.choices) return widget
-
-      const choices = Object.entries(widget.config.choices)
-        .reduce((acc, [ sliceId, sliceValue ]: [string, DynamicSlice]) => {
-          if (sliceValue.type === SlicesTypes.SharedSlice && !sharedSlices.get(sliceId)) return acc
-          return { ...acc, [sliceId]: sliceValue }
-        }, {})
-
-      const config = { ...widget.config, choices }
-
-      return {...widget, config }
-    }
-
-    return widget
-  })
-}
+export function filterMissingSharedSlices(
+	customType: CustomType,
+	sharedSlices: Map<string, SharedSlice>,
+): CustomType {
+	return collectWidgets(customType, (_widgetId, widget) => {
+		if (widget.type === WidgetTypes.Slices) {
+			if (!widget.config || !widget.config.choices) return widget
+
+			const choices = Object.entries(widget.config.choices).reduce(
+				(acc, [sliceId, sliceValue]: [string, DynamicSlice]) => {
+					if (
+						sliceValue.type === SlicesTypes.SharedSlice &&
+						!sharedSlices.get(sliceId)
+					)
+						return acc
+					return { ...acc, [sliceId]: sliceValue }
+				},
+				{},
+			)
+
+			const config = { ...widget.config, choices }
+
+			return { ...widget, config }
+		}
+
+		return widget
+	})
+}

package/src/customtypes/Format.ts

@@ -1,4 +1,4 @@
 export enum Format {
-  Static = 'static',
-  Dynamic = 'dynamic'
-}
+	Static = "static",
+	Dynamic = "dynamic",
+}

package/src/customtypes/Section.ts

@@ -1,11 +1,16 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-import { Format } from './Format'
-import { widgetReader, StaticWidget, DynamicWidget, Widgets } from './widgets/Widget'
-import SharedSlice from './widgets/slices/SharedSlice'
+import { Format } from "./Format"
+import type SharedSlice from "./widgets/slices/SharedSlice"
+import {
+	DynamicWidget,
+	StaticWidget,
+	widgetReader,
+	Widgets,
+} from "./widgets/Widget"
 
 export function sectionReader<F extends Format>(format: F) {
-  return t.record(t.string, widgetReader(format))
+	return t.record(t.string, widgetReader(format))
 }
 
 export const StaticSection = sectionReader(Format.Static)
@@ -15,11 +20,19 @@ export const DynamicSection = sectionReader(Format.Dynamic)
 export type DynamicSection = t.TypeOf<typeof DynamicSection>
 
 export const Sections = {
-  toStatic(dynamic: DynamicSection, sharedSlices: Map<string, SharedSlice>): StaticSection {
-    const section = Object.entries(dynamic)
-      .reduce((acc: { [key: string]: StaticWidget }, [widgetKey, widget]: [string, DynamicWidget]) => {
-        return {...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices)}
-      }, {})
-    return section as StaticSection
-  }
-}
+	toStatic(
+		dynamic: DynamicSection,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticSection {
+		const section = Object.entries(dynamic).reduce(
+			(
+				acc: { [key: string]: StaticWidget },
+				[widgetKey, widget]: [string, DynamicWidget],
+			) => {
+				return { ...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices) }
+			},
+			{},
+		)
+		return section as StaticSection
+	},
+}

package/src/customtypes/index.ts

@@ -1,4 +1,4 @@
-export { Format } from './Format'
-export * as Section from './Section'
-export * as Widgets from './widgets'
-export * from './CustomType'
+export * from "./CustomType"
+export { Format } from "./Format"
+export * as Section from "./Section"
+export * as Widgets from "./widgets"

package/src/customtypes/widgets/Group.ts

@@ -1,29 +1,30 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../../validators/StringOrNull'
-import WidgetTypes from './WidgetTypes'
-import NestableWidget from './nestable/NestableWidget'
+import * as t from "io-ts"
+
+import { StringOrNull } from "../../validators"
+import NestableWidget from "./nestable/NestableWidget"
+import WidgetTypes from "./WidgetTypes"
 
 const GroupConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    repeat: t.boolean,
-    fields: t.record(t.string, NestableWidget)
-  })
+	t.partial({
+		label: StringOrNull,
+		repeat: t.boolean,
+		fields: t.record(t.string, NestableWidget),
+	}),
 )
 type GroupConfig = t.TypeOf<typeof GroupConfig>
 
 const Group = t.exact(
-  t.intersection([
-    t.type({
-      type: t.literal(WidgetTypes.Group)
-    }),
-    t.partial({
-      fieldset: StringOrNull,
-      icon: t.string,
-      description: t.string,
-      config: GroupConfig
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.Group),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			icon: t.string,
+			description: t.string,
+			config: GroupConfig,
+		}),
+	]),
 )
 type Group = t.TypeOf<typeof Group>
 

package/src/customtypes/widgets/UID.ts

@@ -1,26 +1,27 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../../validators/StringOrNull'
-import WidgetTypes from './WidgetTypes'
+import * as t from "io-ts"
+
+import { StringOrNull } from "../../validators"
+import WidgetTypes from "./WidgetTypes"
 
 const UIDConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    useAsTitle: t.boolean,
-    placeholder: t.string
-  })
+	t.partial({
+		label: StringOrNull,
+		useAsTitle: t.boolean,
+		placeholder: t.string,
+	}),
 )
 type UIDConfig = t.TypeOf<typeof UIDConfig>
 
 const UID = t.exact(
-  t.intersection([
-    t.type({
-      type: t.literal(WidgetTypes.UID)
-    }),
-    t.partial({
-      fieldset: StringOrNull,
-      config: UIDConfig
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.UID),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			config: UIDConfig,
+		}),
+	]),
 )
 type UID = t.TypeOf<typeof UID>
 

package/src/customtypes/widgets/Widget.ts

@@ -1,20 +1,15 @@
-import * as t from 'io-ts'
+import * as t from "io-ts"
 
-import UID from './UID'
-import NestableWidget from './nestable/NestableWidget'
-import { slicesReader, Slices } from './slices/Slices'
-import SharedSlice from './slices/SharedSlice'
-import { Format } from '../Format'
-import Group from './Group'
-import WidgetTypes from './WidgetTypes'
+import { Format } from "../Format"
+import Group from "./Group"
+import NestableWidget from "./nestable/NestableWidget"
+import type SharedSlice from "./slices/SharedSlice"
+import { Slices, slicesReader } from "./slices/Slices"
+import UID from "./UID"
+import WidgetTypes from "./WidgetTypes"
 
-export function widgetReader<F extends Format>(format: F){
-  return t.union([
-    UID,
-    NestableWidget,
-    Group,
-    slicesReader(format)
-  ])
+export function widgetReader<F extends Format>(format: F) {
+	return t.union([UID, NestableWidget, Group, slicesReader(format)])
 }
 export const StaticWidget = widgetReader(Format.Static)
 export type StaticWidget = t.TypeOf<typeof StaticWidget>
@@ -22,12 +17,16 @@ export type StaticWidget = t.TypeOf<typeof StaticWidget>
 export const DynamicWidget = widgetReader(Format.Dynamic)
 export type DynamicWidget = t.TypeOf<typeof DynamicWidget>
 
-
 export const Widgets = {
-  toStatic(widget: DynamicWidget, sharedSlices: Map<string, SharedSlice>): StaticWidget {
-    switch(widget.type) {
-      case WidgetTypes.Slices: return Slices.toStatic(widget, sharedSlices)
-      default: return widget as StaticWidget
-    }
-  }
-}
+	toStatic(
+		widget: DynamicWidget,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticWidget {
+		switch (widget.type) {
+			case WidgetTypes.Slices:
+				return Slices.toStatic(widget, sharedSlices)
+			default:
+				return widget as StaticWidget
+		}
+	},
+}

package/src/customtypes/widgets/WidgetTypes.ts

@@ -1,24 +1,24 @@
 enum WidgetTypes {
-  Text = 'Text',
-  RichText = 'StructuredText',
-  Color = 'Color',
-  Image = 'Image',
-  Date = 'Date',
-  Timestamp = 'Timestamp',
-  Number = 'Number',
-  Range = 'Range',
-  Select = 'Select',
-  Link = 'Link',
-  Embed = 'Embed',
-  GeoPoint = 'GeoPoint',
-  Separator = 'Separator',
-  UID = 'UID',
-  BooleanField = 'Boolean',
-  IntegrationField = 'IntegrationFields',
-  Group = 'Group',
-  Slices = 'Slices',
-  // Legacy type for slices
-  LegacySlices = 'Choice'
+	Text = "Text",
+	RichText = "StructuredText",
+	Color = "Color",
+	Image = "Image",
+	Date = "Date",
+	Timestamp = "Timestamp",
+	Number = "Number",
+	Range = "Range",
+	Select = "Select",
+	Link = "Link",
+	Embed = "Embed",
+	GeoPoint = "GeoPoint",
+	Separator = "Separator",
+	UID = "UID",
+	BooleanField = "Boolean",
+	IntegrationField = "IntegrationFields",
+	Group = "Group",
+	Slices = "Slices",
+	// Legacy type for slices
+	LegacySlices = "Choice",
 }
 
-export default WidgetTypes
+export default WidgetTypes

package/src/customtypes/widgets/index.ts

@@ -1,7 +1,7 @@
-export * as Nestable from './nestable'
-export * as Shared from './shared'
-export * as Slices from './slices'
-export * as Widget from './Widget'
-export { default as Group } from './Group'
-export { default as UID } from './UID'
-export { default as WidgetTypes } from './WidgetTypes'
+export { default as Group } from "./Group"
+export * as Nestable from "./nestable"
+export * as Shared from "./shared"
+export * as Slices from "./slices"
+export { default as UID } from "./UID"
+export * as Widget from "./Widget"
+export { default as WidgetTypes } from "./WidgetTypes"

package/src/customtypes/widgets/nestable/BooleanField.ts

@@ -1,30 +1,30 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../../../validators/StringOrNull'
-import WidgetTypes from '../WidgetTypes'
+import * as t from "io-ts"
+
+import { StringOrNull } from "../../../validators"
+import WidgetTypes from "../WidgetTypes"
 
 const BooleanConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    default_value: t.boolean,
-    placeholder_true: t.string,
-    placeholder_false: t.string
-  })
+	t.partial({
+		label: StringOrNull,
+		default_value: t.boolean,
+		placeholder_true: t.string,
+		placeholder_false: t.string,
+	}),
 )
 
 type BooleanConfig = t.TypeOf<typeof BooleanConfig>
 
 const BooleanField = t.exact(
-  t.intersection([
-    t.type({
-      type: t.literal(WidgetTypes.BooleanField)
-    }),
-    t.partial({
-      config: BooleanConfig
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.BooleanField),
+		}),
+		t.partial({
+			config: BooleanConfig,
+		}),
+	]),
 )
 
 type BooleanField = t.TypeOf<typeof BooleanField>
 
-
-export default BooleanField
+export default BooleanField