@prismicio/types-internal 0.2.10 → 0.3.1-beta.0

package/lib/documents/widgets/index.d.ts

@@ -1,4 +1,5 @@
-import { SlicesContent } from "./slices/SlicesContent";
+import * as t from "io-ts";
+import { SlicesContent } from "./slices";
 import StaticWidgetContent from "./StaticWidgetContent";
 export * from "./EmptyContent";
 export * from "./GroupContent";
@@ -28,7 +29,8 @@ export declare const WidgetTypes: {
     readonly IntegrationFields: "IntegrationFieldsContent";
     readonly Separator: "SeparatorContent";
 };
-export declare type WidgetKey = string;
+export declare const WidgetKey: t.Type<string, string, unknown>;
+export declare type WidgetKey = t.TypeOf<typeof WidgetKey>;
 export declare type WidgetContent = SlicesContent | StaticWidgetContent;
 export declare const Widget: {
     fromJson(widgetKey: WidgetKey, widgetValue: unknown, widgetTypes: Map<WidgetKey, string>, widgetPositions: Map<WidgetKey, number>): import("fp-ts/lib/Option").None | import("fp-ts/lib/Option").Some<StaticWidgetContent> | import("fp-ts/lib/Option").Some<SlicesContent>;

package/lib/documents/widgets/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Widget = exports.WidgetTypes = exports.StaticWidgetContent = exports.Slices = exports.Nestable = void 0;
+exports.Widget = exports.WidgetKey = exports.WidgetTypes = exports.StaticWidgetContent = exports.Slices = exports.Nestable = void 0;
 const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../validators/function");
 const EmptyContent_1 = require("./EmptyContent");
 const GroupContent_1 = require("./GroupContent");
 const nestable_1 = require("./nestable");
-const SlicesContent_1 = require("./slices/SlicesContent");
+const slices_1 = require("./slices");
 const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("./StaticWidgetContent"));
 const UIDContent_1 = require("./UIDContent");
 (0, tslib_1.__exportStar)(require("./EmptyContent"), exports);
@@ -21,13 +23,15 @@ exports.WidgetTypes = {
     Empty: EmptyContent_1.EmptyContentType,
     UID: UIDContent_1.UIDContentType,
     Group: GroupContent_1.GroupContentType,
-    slices: SlicesContent_1.SlicesContentType,
+    slices: slices_1.SlicesContentType,
 };
+const widgetKeyRegex = new RegExp("^[^<>]+$");
+exports.WidgetKey = (0, function_1.refineType)(t.string, "WidgetKey", (s) => widgetKeyRegex.test(s));
 exports.Widget = {
     fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions) {
         const fieldType = widgetTypes.get(widgetKey);
         if (fieldType === "Slices") {
-            return SlicesContent_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
+            return slices_1.SlicesContent.fromJson(widgetKey, widgetValue, widgetTypes, widgetPositions);
         }
         else {
             return StaticWidgetContent_1.default.fromJson([], widgetKey, widgetValue, widgetTypes, widgetPositions);

package/lib/documents/widgets/nestable/StructuredTextContent/Block.d.ts

@@ -1,27 +1,70 @@
 import * as t from "io-ts";
+import { RichTextNodeType } from "../../../../customtypes/widgets/nestable";
 export declare const Meta: t.ExactC<t.IntersectionC<[t.PartialC<{
     data: t.UnknownC;
 }>, t.TypeC<{
     start: t.NumberC;
     end: t.NumberC;
-    type: t.StringC;
+    type: t.KeyofC<{
+        heading1: null;
+        heading2: null;
+        heading3: null;
+        heading4: null;
+        heading5: null;
+        heading6: null;
+        paragraph: null;
+        strong: null;
+        em: null;
+        preformatted: null;
+        hyperlink: null;
+        image: null;
+        embed: null;
+        "list-item": null;
+        "o-list-item": null;
+        rtl: null;
+    }>;
 }>]>>;
+export declare type Meta = t.TypeOf<typeof Meta>;
+export declare const Span: t.ExactC<t.IntersectionC<[t.PartialC<{
+    data: t.UnknownC;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+    type: t.KeyofC<{
+        heading1: null;
+        heading2: null;
+        heading3: null;
+        heading4: null;
+        heading5: null;
+        heading6: null;
+        paragraph: null;
+        strong: null;
+        em: null;
+        preformatted: null;
+        hyperlink: null;
+        image: null;
+        embed: null;
+        "list-item": null;
+        "o-list-item": null;
+        rtl: null;
+    }>;
+}>]>>;
+export declare type Span = Meta;
 export declare const ValidatedMetas: t.Type<({
     data?: unknown;
 } & {
     start: number;
     end: number;
-    type: string;
+    type: RichTextNodeType;
 })[], ({
     data?: unknown;
 } & {
     start: number;
     end: number;
-    type: string;
+    type: RichTextNodeType;
 })[], unknown>;
-export declare const ImageBlockType = "image";
 export declare const ImageBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"image">;
+    type: t.LiteralC<RichTextNodeType.image>;
     data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         origin: t.ExactC<t.TypeC<{
             id: t.StringC;
@@ -115,9 +158,8 @@ export declare const ImageBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
 }>]>>;
 export declare type ImageBlock = t.TypeOf<typeof ImageBlock>;
 export declare function checkImageBlock(block: Block): block is ImageBlock;
-export declare const EmbedBlockType = "embed";
 export declare const EmbedBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"embed">;
+    type: t.LiteralC<RichTextNodeType.embed>;
     data: t.Type<import("../EmbedContent").EmbedContentO, unknown, unknown>;
 }>, t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -126,7 +168,7 @@ export declare const EmbedBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
 export declare type EmbedBlock = t.TypeOf<typeof EmbedBlock>;
 export declare function checkEmbedBlock(block: Block): block is EmbedBlock;
 export declare const TextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.Type<string, string, unknown>;
+    type: t.Type<RichTextNodeType, RichTextNodeType, unknown>;
     content: t.IntersectionC<[t.TypeC<{
         text: t.StringC;
     }>, t.PartialC<{
@@ -135,13 +177,13 @@ export declare const TextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
         } & {
             start: number;
             end: number;
-            type: string;
+            type: RichTextNodeType;
         })[], ({
             data?: unknown;
         } & {
             start: number;
             end: number;
-            type: string;
+            type: RichTextNodeType;
         })[], unknown>;
     }>]>;
 }>, t.PartialC<{
@@ -150,7 +192,7 @@ export declare const TextBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
 }>]>>;
 export declare type TextBlock = t.TypeOf<typeof TextBlock>;
 export declare const Block: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"image">;
+    type: t.LiteralC<RichTextNodeType.image>;
     data: t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         origin: t.ExactC<t.TypeC<{
             id: t.StringC;
@@ -242,13 +284,13 @@ export declare const Block: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
     direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
 }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"embed">;
+    type: t.LiteralC<RichTextNodeType.embed>;
     data: t.Type<import("../EmbedContent").EmbedContentO, unknown, unknown>;
 }>, t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
     direction: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
 }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
-    type: t.Type<string, string, unknown>;
+    type: t.Type<RichTextNodeType, RichTextNodeType, unknown>;
     content: t.IntersectionC<[t.TypeC<{
         text: t.StringC;
     }>, t.PartialC<{
@@ -257,13 +299,13 @@ export declare const Block: t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
         } & {
             start: number;
             end: number;
-            type: string;
+            type: RichTextNodeType;
         })[], ({
             data?: unknown;
         } & {
             start: number;
             end: number;
-            type: string;
+            type: RichTextNodeType;
         })[], unknown>;
     }>]>;
 }>, t.PartialC<{

package/lib/documents/widgets/nestable/StructuredTextContent/Block.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Block = exports.TextBlock = exports.checkEmbedBlock = exports.EmbedBlock = exports.EmbedBlockType = exports.checkImageBlock = exports.ImageBlock = exports.ImageBlockType = exports.ValidatedMetas = exports.Meta = void 0;
+exports.Block = exports.TextBlock = exports.checkEmbedBlock = exports.EmbedBlock = exports.checkImageBlock = exports.ImageBlock = exports.ValidatedMetas = exports.Span = exports.Meta = void 0;
 const tslib_1 = require("tslib");
 const E = (0, tslib_1.__importStar)(require("fp-ts/lib/Either"));
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const nestable_1 = require("../../../../customtypes/widgets/nestable");
 const validators_1 = require("../../../../validators");
 const function_1 = require("../../../../validators/function");
 const EmbedContent_1 = require("../EmbedContent");
@@ -16,9 +17,11 @@ exports.Meta = t.exact(t.intersection([
     t.type({
         start: t.number,
         end: t.number,
-        type: t.string,
+        type: nestable_1.RichTextNodeTypeCodec,
     }),
 ]));
+// export alias for code clarity
+exports.Span = exports.Meta;
 exports.ValidatedMetas = new t.Type("ValidatedMetas", (metas) => Array.isArray(metas) && metas.every(exports.Meta.is), (metas, c) => {
     if (Array.isArray(metas)) {
         const res = metas
@@ -42,10 +45,9 @@ exports.ValidatedMetas = new t.Type("ValidatedMetas", (metas) => Array.isArray(m
     else
         return t.failure(metas, c);
 }, (m) => t.array(exports.Meta).encode(m));
-exports.ImageBlockType = "image";
 exports.ImageBlock = t.exact(t.intersection([
     t.type({
-        type: t.literal(exports.ImageBlockType),
+        type: t.literal(nestable_1.RichTextNodeType.image),
         data: t.intersection([
             ImageContent_1.ImageContentView,
             t.partial({
@@ -59,13 +61,12 @@ exports.ImageBlock = t.exact(t.intersection([
     }),
 ]));
 function checkImageBlock(block) {
-    return block.type === exports.ImageBlockType;
+    return block.type === nestable_1.RichTextNodeType.image;
 }
 exports.checkImageBlock = checkImageBlock;
-exports.EmbedBlockType = "embed";
 exports.EmbedBlock = t.exact(t.intersection([
     t.type({
-        type: t.literal(exports.EmbedBlockType),
+        type: t.literal(nestable_1.RichTextNodeType.embed),
         data: EmbedContent_1.EmbedContent,
     }),
     t.partial({
@@ -74,12 +75,12 @@ exports.EmbedBlock = t.exact(t.intersection([
     }),
 ]));
 function checkEmbedBlock(block) {
-    return block.type === exports.EmbedBlockType;
+    return block.type === nestable_1.RichTextNodeType.embed;
 }
 exports.checkEmbedBlock = checkEmbedBlock;
 exports.TextBlock = t.exact(t.intersection([
     t.type({
-        type: (0, function_1.refineType)(t.string, `string which isn't ${exports.ImageBlockType} ${exports.EmbedBlockType}`, (s) => s !== exports.ImageBlockType && s !== exports.EmbedBlockType),
+        type: (0, function_1.refineType)(nestable_1.RichTextNodeTypeCodec, `string which isn't ${nestable_1.RichTextNodeType.image} ${nestable_1.RichTextNodeType.embed}`, (s) => s !== nestable_1.RichTextNodeType.image && s !== nestable_1.RichTextNodeType.embed),
         content: t.intersection([
             t.type({
                 text: t.string,

package/lib/documents/widgets/slices/SlicesContent.d.ts

@@ -1,4 +1,5 @@
 import * as O from "fp-ts/Option";
+import * as t from "io-ts";
 import { SliceWidgetContent } from "./SliceWidgetContent";
 export declare type SlicesContentItem = {
     key: string;
@@ -11,6 +12,8 @@ export declare type SlicesContent = {
     __TYPE__: typeof SlicesContentType;
     value: SlicesContentItem[];
 };
+export declare const SliceKey: t.Type<string, string, unknown>;
+export declare type SliceKey = t.TypeOf<typeof SliceKey>;
 export declare const SlicesContent: {
     itemsCodec: (value: unknown, codecWidget: (n: string, v: unknown) => O.Option<SliceWidgetContent>) => O.Option<SlicesContentItem>;
     fromJson: (key: string, value: unknown, fieldTypes: Map<string, string>, fieldPositions: Map<string, number>) => O.Option<SlicesContent>;

package/lib/documents/widgets/slices/SlicesContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlicesContent = exports.SlicesContentType = void 0;
+exports.SlicesContent = exports.SliceKey = exports.SlicesContentType = void 0;
 const tslib_1 = require("tslib");
 const A = (0, tslib_1.__importStar)(require("fp-ts/Array"));
 const function_1 = require("fp-ts/function");
@@ -9,9 +9,11 @@ const t = (0, tslib_1.__importStar)(require("io-ts"));
 const function_2 = require("../../../validators/function");
 const SliceWidgetContent_1 = require("./SliceWidgetContent");
 exports.SlicesContentType = "SliceContentType";
+const sliceKeyRegex = new RegExp("^[-_\\w]+\\$[-\\w]+$");
+exports.SliceKey = (0, function_2.refineType)(t.string, "SliceKey", (s) => sliceKeyRegex.test(s));
 const codec = t.exact(t.intersection([
     t.type({
-        key: t.string,
+        key: exports.SliceKey,
         value: t.unknown,
     }),
     t.partial({

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "0.2.10",
+	"version": "0.3.1-beta.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/customtypes/CustomType.ts

@@ -38,7 +38,7 @@ function customTypeReader<T extends StaticSection | DynamicSection>(
 				id: t.string,
 				label: StringOrNull,
 				repeatable: withFallback(t.boolean, true),
-				json: t.record(t.string, codec),
+				json: t.record(t.string, codec), //tab name => tab data
 				status: withFallback(t.boolean, true),
 			}),
 			t.partial({

package/src/customtypes/Section.ts

@@ -1,12 +1,13 @@
 import * as t from "io-ts"
 
-import type { SharedSlice } from "./widgets/slices/SharedSlice"
+import { WidgetKey } from "../documents/widgets"
+import type { SharedSlice } from "./widgets/slices"
 import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
 
 export function sectionReader<T extends StaticWidget | DynamicWidget>(
 	codec: t.Type<T, unknown>,
 ) {
-	return t.record(t.string, codec)
+	return t.record(WidgetKey, codec) // WidgetId -> Widget Data
 }
 
 export const StaticSection = sectionReader(StaticWidget)

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

@@ -1,4 +1,4 @@
-import { either } from "fp-ts/lib/Either"
+import { either, getOrElseW } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
 import { StringOrNull } from "../../../validators"
@@ -26,46 +26,24 @@ export enum RichTextNodeType {
 	rtl = "rtl",
 }
 
-export function parseRichTextNodeType(
-	str: string,
-): RichTextNodeType | undefined {
-	switch (str) {
-		case RichTextNodeType.heading1:
-			return RichTextNodeType.heading1
-		case RichTextNodeType.heading2:
-			return RichTextNodeType.heading2
-		case RichTextNodeType.heading3:
-			return RichTextNodeType.heading3
-		case RichTextNodeType.heading4:
-			return RichTextNodeType.heading4
-		case RichTextNodeType.heading5:
-			return RichTextNodeType.heading5
-		case RichTextNodeType.heading6:
-			return RichTextNodeType.heading6
-		case RichTextNodeType.paragraph:
-			return RichTextNodeType.paragraph
-		case RichTextNodeType.strong:
-			return RichTextNodeType.strong
-		case RichTextNodeType.em:
-			return RichTextNodeType.em
-		case RichTextNodeType.preformatted:
-			return RichTextNodeType.preformatted
-		case RichTextNodeType.hyperlink:
-			return RichTextNodeType.hyperlink
-		case RichTextNodeType.image:
-			return RichTextNodeType.image
-		case RichTextNodeType.embed:
-			return RichTextNodeType.embed
-		case RichTextNodeType.list:
-			return RichTextNodeType.list
-		case RichTextNodeType.orderedList:
-			return RichTextNodeType.orderedList
-		case RichTextNodeType.rtl:
-			return RichTextNodeType.rtl
-		default:
-			return
-	}
-}
+export const RichTextNodeTypeCodec = t.keyof({
+	[RichTextNodeType.heading1]: null,
+	[RichTextNodeType.heading2]: null,
+	[RichTextNodeType.heading3]: null,
+	[RichTextNodeType.heading4]: null,
+	[RichTextNodeType.heading5]: null,
+	[RichTextNodeType.heading6]: null,
+	[RichTextNodeType.paragraph]: null,
+	[RichTextNodeType.strong]: null,
+	[RichTextNodeType.em]: null,
+	[RichTextNodeType.preformatted]: null,
+	[RichTextNodeType.hyperlink]: null,
+	[RichTextNodeType.image]: null,
+	[RichTextNodeType.embed]: null,
+	[RichTextNodeType.list]: null,
+	[RichTextNodeType.orderedList]: null,
+	[RichTextNodeType.rtl]: null,
+})
 
 const RichTextOptions = new t.Type<string, string, unknown>(
 	"RichTextOptions",
@@ -76,7 +54,11 @@ const RichTextOptions = new t.Type<string, string, unknown>(
 			(s: string | null) => {
 				if (!s) return t.success(DEFAULT_OPTION)
 				const entries = s.split(",").map((e: string) => e.trim())
-				const filtered = entries.filter((entry) => parseRichTextNodeType(entry))
+				const filtered = entries.filter((entry) => {
+					return getOrElseW(() => undefined)(
+						RichTextNodeTypeCodec.decode(entry),
+					)
+				})
 				if (!filtered.length) return t.success(DEFAULT_OPTION)
 
 				return t.success(filtered.join(","))

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

@@ -1,5 +1,6 @@
 import * as t from "io-ts"
 
+import { WidgetKey } from "../../../documents/widgets"
 import { StringOrNull } from "../../../validators"
 import NestableWidget from "../nestable/NestableWidget"
 import SlicesTypes from "./SlicesTypes"
@@ -21,8 +22,8 @@ const CompositeSlice = t.exact(
 			description: t.string,
 			icon: t.string,
 			display: t.string,
-			"non-repeat": t.record(t.string, NestableWidget),
-			repeat: t.record(t.string, NestableWidget),
+			"non-repeat": t.record(WidgetKey, NestableWidget),
+			repeat: t.record(WidgetKey, NestableWidget),
 			config: CompositeSliceConfig,
 		}),
 	]),

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

@@ -1,6 +1,7 @@
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
+import { WidgetKey } from "../../../documents/widgets"
 import NestableWidget from "../nestable/NestableWidget"
 import SlicesTypes from "./SlicesTypes"
 
@@ -19,8 +20,8 @@ export const Variation = t.exact(
 		}),
 		t.partial({
 			display: t.string,
-			primary: t.record(t.string, NestableWidget),
-			items: t.record(t.string, NestableWidget),
+			primary: t.record(WidgetKey, NestableWidget),
+			items: t.record(WidgetKey, NestableWidget),
 		}),
 	]),
 )

package/src/documents/widgets/index.ts

@@ -1,7 +1,10 @@
+import * as t from "io-ts"
+
+import { refineType } from "../../validators/function"
 import { EmptyContentType } from "./EmptyContent"
 import { GroupContentType } from "./GroupContent"
 import { NestableTypes } from "./nestable"
-import { SlicesContent, SlicesContentType } from "./slices/SlicesContent"
+import { SlicesContent, SlicesContentType } from "./slices"
 import StaticWidgetContent from "./StaticWidgetContent"
 import { UIDContentType } from "./UIDContent"
 
@@ -24,7 +27,12 @@ export const WidgetTypes = {
 	slices: SlicesContentType,
 } as const
 
-export type WidgetKey = string
+const widgetKeyRegex = new RegExp("^[^<>]+$")
+export const WidgetKey = refineType(t.string, "WidgetKey", (s: string) =>
+	widgetKeyRegex.test(s),
+)
+export type WidgetKey = t.TypeOf<typeof WidgetKey>
+
 export type WidgetContent = SlicesContent | StaticWidgetContent
 
 export const Widget = {

package/src/documents/widgets/nestable/StructuredTextContent/Block.ts

@@ -1,6 +1,10 @@
 import * as E from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
+import {
+	RichTextNodeType,
+	RichTextNodeTypeCodec,
+} from "../../../../customtypes/widgets/nestable"
 import { StringOrNull } from "../../../../validators"
 import { nullable, refineType } from "../../../../validators/function"
 import { EmbedContent } from "../EmbedContent"
@@ -15,12 +19,15 @@ export const Meta = t.exact(
 		t.type({
 			start: t.number,
 			end: t.number,
-			type: t.string,
+			type: RichTextNodeTypeCodec,
 		}),
 	]),
 )
+export type Meta = t.TypeOf<typeof Meta>
 
-type Meta = t.TypeOf<typeof Meta>
+// export alias for code clarity
+export const Span = Meta
+export type Span = Meta
 
 export const ValidatedMetas = new t.Type<Meta[], Meta[], unknown>(
 	"ValidatedMetas",
@@ -51,12 +58,10 @@ export const ValidatedMetas = new t.Type<Meta[], Meta[], unknown>(
 	(m) => t.array(Meta).encode(m),
 )
 
-export const ImageBlockType = "image"
-
 export const ImageBlock = t.exact(
 	t.intersection([
 		t.type({
-			type: t.literal(ImageBlockType),
+			type: t.literal(RichTextNodeType.image),
 			data: t.intersection([
 				ImageContentView,
 				t.partial({
@@ -72,14 +77,13 @@ export const ImageBlock = t.exact(
 )
 export type ImageBlock = t.TypeOf<typeof ImageBlock>
 export function checkImageBlock(block: Block): block is ImageBlock {
-	return block.type === ImageBlockType
+	return block.type === RichTextNodeType.image
 }
 
-export const EmbedBlockType = "embed"
 export const EmbedBlock = t.exact(
 	t.intersection([
 		t.type({
-			type: t.literal(EmbedBlockType),
+			type: t.literal(RichTextNodeType.embed),
 			data: EmbedContent,
 		}),
 		t.partial({
@@ -90,16 +94,16 @@ export const EmbedBlock = t.exact(
 )
 export type EmbedBlock = t.TypeOf<typeof EmbedBlock>
 export function checkEmbedBlock(block: Block): block is EmbedBlock {
-	return block.type === EmbedBlockType
+	return block.type === RichTextNodeType.embed
 }
 
 export const TextBlock = t.exact(
 	t.intersection([
 		t.type({
 			type: refineType(
-				t.string,
-				`string which isn't ${ImageBlockType} ${EmbedBlockType}`,
-				(s) => s !== ImageBlockType && s !== EmbedBlockType,
+				RichTextNodeTypeCodec,
+				`string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`,
+				(s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed,
 			),
 			content: t.intersection([
 				t.type({

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

@@ -3,7 +3,7 @@ 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 { nullable, refineType } from "../../../validators/function"
 import { SliceWidgetContent } from "./SliceWidgetContent"
 
 export type SlicesContentItem = {
@@ -18,10 +18,17 @@ export type SlicesContent = {
 	__TYPE__: typeof SlicesContentType
 	value: SlicesContentItem[]
 }
+
+const sliceKeyRegex = new RegExp("^[-_\\w]+\\$[-\\w]+$")
+export const SliceKey = refineType(t.string, "SliceKey", (s: string) =>
+	sliceKeyRegex.test(s),
+)
+export type SliceKey = t.TypeOf<typeof SliceKey>
+
 const codec = t.exact(
 	t.intersection([
 		t.type({
-			key: t.string,
+			key: SliceKey,
 			value: t.unknown,
 		}),
 		t.partial({

package/lib/customtypes/Format.d.ts

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

package/lib/customtypes/Format.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Format = void 0;
-var Format;
-(function (Format) {
-    Format["Static"] = "static";
-    Format["Dynamic"] = "dynamic";
-})(Format = exports.Format || (exports.Format = {}));