@prismicio/types-internal 0.1.0

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

@@ -0,0 +1,40 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+import ImageConstraint from '../shared/ImageConstraint'
+
+const Thumbnail = t.exact(
+  t.intersection([
+    t.type({
+      name: t.string
+    }),
+    ImageConstraint
+  ])
+)
+type Thumbnail = t.TypeOf<typeof Thumbnail>
+
+const ImageConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    constraint: ImageConstraint,
+    thumbnails: t.array(Thumbnail)
+  })
+)
+type ImageConfig = t.TypeOf<typeof ImageConfig>
+
+
+const Image = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Image)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: ImageConfig
+    })
+  ])
+)
+type Image = t.TypeOf<typeof Image>
+
+export default Image

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

@@ -0,0 +1,27 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+
+const IntegrationFieldConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    catalog: t.string
+  })
+)
+type IntegrationFieldConfig = t.TypeOf<typeof IntegrationFieldConfig>
+
+const IntegrationField = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.IntegrationField)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: IntegrationFieldConfig
+    })
+  ])
+)
+type IntegrationField = t.TypeOf<typeof IntegrationField>
+
+export default IntegrationField

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

@@ -0,0 +1,85 @@
+import * as t from 'io-ts'
+import { withFallback  } from 'io-ts-types/lib/withFallback'
+import { either } from 'fp-ts/lib/Either'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+
+const arrayString = (entries: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(entries instanceof Array) {
+    const isValidEntries = entries.reduce((acc, l) => acc && typeof l === 'string', true) 
+    if(isValidEntries) return t.success(entries)
+  }
+}
+
+const plainString = (entries: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(typeof entries === 'string') {
+    return t.success([entries])
+  }
+}
+
+const MasksArrayString = new t.Type<Array<string>, object, unknown>(
+  'MasksArrayString',
+  (u: unknown): u is any => {
+    return u instanceof Array
+  },
+  (u: unknown, context: t.Context) => {
+    return either.chain(
+      t.union([
+        t.array(t.string),
+        t.string,
+      ]).validate(u, context), (masks) => {
+        return (
+          arrayString(masks) ||
+          plainString(masks) ||
+          t.failure(u, context)
+        )
+      }
+    )
+  },
+  res => res
+)
+
+const LinkConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    useAsTitle: t.boolean,
+    placeholder: t.string,
+    select: withFallback(
+      t.union([
+        t.literal('media'),
+        t.literal('document'),
+        t.literal('web'),
+        t.null
+      ]),
+      null
+    ),
+    customtypes: t.array(t.string), // `customtypes` and `masks` are alternatives
+    masks: MasksArrayString,
+    tags: MasksArrayString,
+    allowTargetBlank: t.boolean
+  })
+)
+type LinkConfig = t.TypeOf<typeof LinkConfig>
+
+const Link = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Link)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: LinkConfig
+    })
+  ])
+)
+type Link = t.TypeOf<typeof Link>
+
+export default Link

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

@@ -0,0 +1,39 @@
+import * as t from 'io-ts'
+
+import Color from './Color'
+import BooleanField from './BooleanField'
+import Date from './Date'
+import Embed from './Embed'
+import GeoPoint from './GeoPoint'
+import Number from './Number'
+import Range from './Range'
+import RichText from './RichText'
+import Select from './Select'
+import Separator from './Separator'
+import Text from './Text'
+import Timestamp from './Timestamp'
+import Link from './Link'
+import Image from './Image'
+import IntegrationField from './IntegrationField'
+
+const NestableWidget = t.union([
+  Color,
+  BooleanField,
+  Embed,
+  GeoPoint,
+  Date,
+  Number,
+  Range,
+  RichText,
+  Select,
+  Separator,
+  Text,
+  Timestamp,
+  Link,
+  Image,
+  IntegrationField
+])
+
+type NestableWidget = t.TypeOf<typeof NestableWidget>
+
+export default NestableWidget

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

@@ -0,0 +1,30 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+import { NumberFromString } from 'io-ts-types/lib/NumberFromString'
+
+const NumberConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    min: t.union([t.number, NumberFromString]),
+    max: t.union([t.number, NumberFromString]),
+    step: t.union([t.number, NumberFromString])
+  })
+)
+type NumberConfig = t.TypeOf<typeof NumberConfig>
+
+const Number = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Number)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: NumberConfig
+    })
+  ])
+)
+type Number = t.TypeOf<typeof Number>
+
+export default Number

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

@@ -0,0 +1,30 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+import { NumberFromString } from 'io-ts-types/lib/NumberFromString'
+
+const RangeConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    min: t.union([t.number, NumberFromString]),
+    max: t.union([t.number, NumberFromString]),
+    step: t.union([t.number, NumberFromString]),
+  })
+)
+type RangeConfig = t.TypeOf<typeof RangeConfig>
+
+const Range = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Range)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: RangeConfig
+    })
+  ])
+)
+type Range = t.TypeOf<typeof Range>
+
+export default Range

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

@@ -0,0 +1,160 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import { either } from 'fp-ts/lib/Either'
+import WidgetTypes from '../WidgetTypes'
+import ImageConstraint from '../shared/ImageConstraint'
+
+const DEFAULT_OPTION = 'paragraph'
+const options = [
+  'heading1',
+  'heading2',
+  'heading3',
+  'heading4',
+  'heading5',
+  'heading6',
+  'paragraph',
+  'strong',
+  'em',
+  'preformatted',
+  'hyperlink',
+  'image',
+  'embed',
+  'list-item',
+  'o-list-item',
+  'rtl'
+];
+
+const RichTextOptions = new t.Type<string, string, unknown>(
+  'RichTextOptions',
+  (u: unknown): u is string => typeof u === 'string',
+  (u: unknown, context: t.Context) => {
+    return either.chain(
+      t.union([
+        t.string,
+        t.null
+      ]).validate(u as unknown, context), (s: string | null) => {
+        if(!s) return t.success(DEFAULT_OPTION)
+        const entries = s.split(',').map((e: string) => e.trim())
+        const filtered = entries.filter(entry => options.includes(entry))
+        if(!filtered.length) return t.success(DEFAULT_OPTION)
+        
+        return t.success(filtered.join(','))
+      }
+    );
+  },
+  a => a
+)
+
+
+const NoLabels = (labels: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(!labels) return t.success([])
+}
+
+const LabelsAsObject = (labels: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(labels instanceof Object) {
+    const labelsObj = labels as { [x: string]: {  name: string }[] }
+    
+    // empty labels
+    if(!Object.entries(labelsObj).length) return t.success([])
+    
+    // weird case labels with empty key as parent
+    if(labelsObj['']) {
+      return t.success(labelsObj[''].map(l => l.name))
+    }
+
+    const convertedObjectToArray = Object.entries(labelsObj)
+      .reduce<ReadonlyArray<string>>((acc, [, labelsEntries]) => {
+        return acc.concat(labelsEntries.map(l => l.name))
+      }, [])
+      .filter(Boolean)
+
+    return t.success(convertedObjectToArray)
+  }
+}
+
+const LabelsAsArray = (labels: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(labels instanceof Array) {
+    const isValidLabels = labels.reduce((acc, l) => acc && typeof l === 'string', true) 
+    if(isValidLabels) return t.success(labels)
+  }
+}
+
+const LabelsAsString = (labels: string | string[] | {
+  [x: string]: {
+      name: string;
+  }[];
+} | null) => {
+  if(typeof labels === 'string') {
+    return t.success([labels])
+  }
+}
+
+const RichTextLabels = new t.Type<Array<string>, object, unknown>(
+  'RichTextLabels',
+  (u: unknown): u is any => {
+    return u instanceof Array
+  },
+  (u: unknown, context: t.Context) => {
+    const legacyValidator = t.record(t.string, t.array(t.record(t.literal("name"), t.string)))
+    const validator = t.array(t.string)
+
+    return either.chain(
+      t.union([
+        legacyValidator,
+        validator,
+        t.string,
+        t.null,
+      ]).validate(u, context), (labels) => {
+        return (
+          NoLabels(labels) ||
+          LabelsAsArray(labels) ||
+          LabelsAsObject(labels) ||
+          LabelsAsString(labels) ||
+          t.failure(u, context)
+        )
+      }
+    )
+  },
+  res => res
+)
+
+const RichTextConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    useAsTitle: t.boolean,
+    single: RichTextOptions,
+    multi: RichTextOptions,
+    imageConstraint: ImageConstraint,
+    labels: RichTextLabels,
+    allowTargetBlank: t.boolean
+  })
+)
+type RichTextConfig = t.TypeOf<typeof RichTextConfig>
+
+const RichText = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.RichText)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: RichTextConfig
+    })
+  ])
+)
+type RichText = t.TypeOf<typeof RichText>
+
+export default RichText

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

@@ -0,0 +1,32 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import { StringFromBoolean } from '../../../validators/StringFromBoolean'
+import WidgetTypes from '../WidgetTypes'
+
+import { StringFromNumber } from '../../../validators/StringFromNumber'
+
+const SelectConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    default_value: t.string,
+    options: t.array(t.union([t.string, StringFromNumber, StringFromBoolean]))
+  })
+)
+type SelectConfig = t.TypeOf<typeof SelectConfig>
+
+const Select = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Select)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: SelectConfig
+    })
+  ])
+)
+type Select = t.TypeOf<typeof Select>
+
+export default Select
+

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

@@ -0,0 +1,24 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+
+const SeparatorConfig = t.exact(
+  t.partial({
+    label: StringOrNull
+  })
+)
+type SeparatorConfig = t.TypeOf<typeof SeparatorConfig>
+
+const Separator = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Separator)
+    }),
+    t.partial({
+      config: SeparatorConfig
+    })
+  ])
+)
+type Separator = t.TypeOf<typeof Separator>
+
+export default Separator

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

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

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

@@ -0,0 +1,27 @@
+import * as t from 'io-ts'
+import { StringOrNull } from '../../../validators/StringOrNull'
+import WidgetTypes from '../WidgetTypes'
+
+const TimestampConfig = t.exact(
+  t.partial({
+    label: StringOrNull,
+    placeholder: t.string,
+    default: t.string
+  })
+)
+type TimestampConfig = t.TypeOf<typeof TimestampConfig>
+
+const Timestamp = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(WidgetTypes.Timestamp)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      config: TimestampConfig
+    })
+  ])
+)
+type Timestamp = t.TypeOf<typeof Timestamp>
+
+export default Timestamp

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

@@ -0,0 +1,15 @@
+export { default as BooleanField } from './BooleanField'
+export { default as Color } from './Color'
+export { default as Date } from './Date'
+export { default as GeoPoint } from './GeoPoint'
+export { default as Image } from './Image'
+export { default as IntegrationField } from './IntegrationField'
+export { default as Link } from './Link'
+export { default as NestableWidget } from './NestableWidget'
+export { default as Number } from './Number'
+export { default as Range } from './Range'
+export { default as RichText } from './RichText'
+export { default as Select } from './Select'
+export { default as Separator } from './Separator'
+export { default as Text } from './Text'
+export { default as Timestamp } from './Timestamp'

package/src/customtypes/widgets/shared/ImageConstraint.ts

@@ -0,0 +1,39 @@
+import * as t from 'io-ts'
+import { either } from 'fp-ts/lib/Either'
+import { IntFromString } from 'io-ts-types/lib/IntFromString'
+
+import { IntFromNumber } from '../../../validators/IntFromNumber'
+import { IntFromPixels } from '../../../validators/IntFromPixels'
+
+const SideConstraint = new t.Type<number | null, any, unknown>(
+  'SideConstraints',
+  (u: unknown): u is any => {
+    return !u || typeof u === 'number'
+  },
+  (u: unknown, context: t.Context) => {
+    return either.chain(
+      t.union([
+        t.literal('auto'),
+        t.literal(''),
+        t.Int,
+        IntFromString,
+        IntFromNumber,
+        IntFromPixels,
+        t.null
+      ]).validate(u, context), (constraint) => {
+        if(constraint === 'auto' || constraint === '') return t.success(null)
+        return t.success(constraint)
+      }
+    )
+  },
+  res => res
+)
+
+const ImageConstraint = t.partial({
+  width: SideConstraint,
+  height: SideConstraint
+})
+
+type ImageConstraint = t.TypeOf<typeof ImageConstraint>
+
+export default ImageConstraint

package/src/customtypes/widgets/shared/index.ts

@@ -0,0 +1 @@
+export { default as ImageConstraint } from './ImageConstraint'

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -0,0 +1,32 @@
+import * as t from 'io-ts'
+
+import SlicesTypes from './SlicesTypes'
+import NestableWidget from "../nestable/NestableWidget"
+import { StringOrNull } from '../../../validators/StringOrNull'
+
+const CompositeSliceConfig = t.exact(
+  t.partial({
+    label: StringOrNull
+  })
+)
+type CompositeSliceConfig = t.TypeOf<typeof CompositeSliceConfig>
+
+const CompositeSlice = t.exact(
+  t.intersection([
+    t.type({
+      type: t.literal(SlicesTypes.Slice)
+    }),
+    t.partial({
+      fieldset: StringOrNull,
+      description: t.string,
+      icon: t.string,
+      display: t.string,
+      'non-repeat': t.record(t.string, NestableWidget),
+      repeat: t.record(t.string, NestableWidget),
+      config: CompositeSliceConfig
+    })
+  ])
+)
+type CompositeSlice = t.TypeOf<typeof CompositeSlice>
+
+export default CompositeSlice

package/src/customtypes/widgets/slices/LegacySlice.ts

@@ -0,0 +1,15 @@
+import * as t from 'io-ts'
+
+import UID from '../UID'
+import NestableWidget from '../nestable/NestableWidget'
+import Group from '../Group'
+
+const LegacySlice = t.union([
+  UID,
+  NestableWidget,
+  Group
+])
+
+type LegacySlice = t.TypeOf<typeof LegacySlice>
+
+export default LegacySlice

package/src/customtypes/widgets/slices/SharedSlice.ts

@@ -0,0 +1,44 @@
+import * as t from 'io-ts'
+import { withFallback } from 'io-ts-types/lib/withFallback'
+import NestableWidget from '../nestable/NestableWidget'
+import SlicesTypes from './SlicesTypes'
+
+const IMAGE_PLACEHOLDER_URL = 'https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format'
+
+const Variation = t.exact(
+  t.intersection([
+    t.type({
+      id: t.string,
+      name: t.string,
+      description: t.string,
+      imageUrl: withFallback(t.string, IMAGE_PLACEHOLDER_URL),
+      docURL: t.string,
+      version: t.string
+    }),
+    t.partial({
+      display: t.string,
+      primary: t.record(t.string, NestableWidget),
+      items: t.record(t.string, NestableWidget)
+    })
+  ])
+)
+
+type Variation = t.TypeOf<typeof Variation>
+
+const SharedSlice = t.exact(
+  t.intersection([
+    t.type({
+      id: t.string,
+      type: t.literal(SlicesTypes.SharedSlice),
+      name: t.string,
+      variations: t.array(Variation)
+    }),
+    t.partial({
+      description: t.string
+    })
+  ])
+)
+
+type SharedSlice = t.TypeOf<typeof SharedSlice>
+
+export default SharedSlice

package/src/customtypes/widgets/slices/SharedSliceRef.ts

@@ -0,0 +1,12 @@
+import * as t from 'io-ts'
+
+import SlicesTypes from './SlicesTypes'
+
+const SharedSliceRef = t.exact(
+  t.type({
+    type: t.literal(SlicesTypes.SharedSlice)
+  })
+)
+type SharedSliceRef = t.TypeOf<typeof SharedSliceRef>
+
+export default SharedSliceRef