@prismicio/types-internal 0.1.1 → 0.2.0

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

@@ -1,159 +1,189 @@
-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'
+import { either } from "fp-ts/lib/Either"
+import * as t from "io-ts"
 
-const DEFAULT_OPTION = 'paragraph'
+import { StringOrNull } from "../../../validators"
+import ImageConstraint from "../shared/ImageConstraint"
+import WidgetTypes from "../WidgetTypes"
+
+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'
-];
+	"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
-)
+	"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, 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 NoLabels = (
+	labels:
+		| string
+		| string[]
+		| {
+				[x: string]: {
+					name: string
+				}[]
+		  }
+		| null,
+) => {
+	if (!labels) return t.success([])
+	return
 }
 
-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 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)
+	}
+	return
 }
 
-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 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)
+	}
+	return
 }
 
-const LabelsAsString = (labels: string | string[] | {
-  [x: string]: {
-      name: string;
-  }[];
-} | null) => {
-  if(typeof labels === 'string') {
-    return t.success([labels])
-  }
+const LabelsAsString = (
+	labels:
+		| string
+		| string[]
+		| {
+				[x: string]: {
+					name: string
+				}[]
+		  }
+		| null,
+) => {
+	if (typeof labels === "string") {
+		return t.success([labels])
+	}
+	return
 }
 
 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
+	"RichTextLabels",
+	(u: unknown): u is Array<string> => {
+		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
-  })
+	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
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.RichText),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			config: RichTextConfig,
+		}),
+	]),
 )
 type RichText = t.TypeOf<typeof RichText>
 

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

@@ -1,32 +1,33 @@
-import * as t from 'io-ts'
-import { StringOrNull } from '../../../validators/StringOrNull'
-import { StringFromBoolean } from '../../../validators/StringFromBoolean'
-import WidgetTypes from '../WidgetTypes'
+import * as t from "io-ts"
 
-import { StringFromNumber } from '../../../validators/StringFromNumber'
+import {
+	StringFromBoolean,
+	StringFromNumber,
+	StringOrNull,
+} from "../../../validators"
+import WidgetTypes from "../WidgetTypes"
 
 const SelectConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    placeholder: t.string,
-    default_value: t.string,
-    options: t.array(t.union([t.string, StringFromNumber, StringFromBoolean]))
-  })
+	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
-    })
-  ])
+	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

@@ -1,23 +1,24 @@
-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 SeparatorConfig = t.exact(
-  t.partial({
-    label: StringOrNull
-  })
+	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
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.Separator),
+		}),
+		t.partial({
+			config: SeparatorConfig,
+		}),
+	]),
 )
 type Separator = t.TypeOf<typeof Separator>
 

package/src/customtypes/widgets/nestable/Text.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 TextConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    useAsTitle: t.boolean,
-    placeholder: t.string
-  })
+	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
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.Text),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			config: TextConfig,
+		}),
+	]),
 )
 type Text = t.TypeOf<typeof Text>
 

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

@@ -1,27 +1,28 @@
-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 TimestampConfig = t.exact(
-  t.partial({
-    label: StringOrNull,
-    placeholder: t.string,
-    default: t.string
-  })
+	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
-    })
-  ])
+	t.intersection([
+		t.type({
+			type: t.literal(WidgetTypes.Timestamp),
+		}),
+		t.partial({
+			fieldset: StringOrNull,
+			config: TimestampConfig,
+		}),
+	]),
 )
 type Timestamp = t.TypeOf<typeof Timestamp>
 
-export default Timestamp
+export default Timestamp

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

@@ -1,15 +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'
+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

@@ -1,37 +1,39 @@
-import * as t from 'io-ts'
-import { either } from 'fp-ts/lib/Either'
-import { IntFromString } from 'io-ts-types/lib/IntFromString'
+import { either } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+import { IntFromString } from "io-ts-types/lib/IntFromString"
 
-import { IntFromNumber } from '../../../validators/IntFromNumber'
-import { IntFromPixels } from '../../../validators/IntFromPixels'
+import { IntFromNumber, IntFromPixels } from "../../../validators"
 
-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 SideConstraint = new t.Type<number | null, unknown, unknown>(
+	"SideConstraints",
+	(u: unknown): u is number | null => {
+		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
+	width: SideConstraint,
+	height: SideConstraint,
 })
 
 type ImageConstraint = t.TypeOf<typeof ImageConstraint>

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

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