@prismicio/types-internal 3.17.0-alpha.2 → 3.17.0-pr.144.0c8207f

package/dist/content/fields/nestable/RichTextContent/Blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blocks.d.ts","names":[],"sources":["../../../../../src/content/fields/nestable/RichTextContent/Blocks.ts"],"mappings":"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"}

package/dist/content/fields/nestable/RichTextContent/Blocks.js

@@ -0,0 +1,141 @@
+import { nullable, refineType } from "../../../../validators/function.js";
+import StringOrNull_default from "../../../../validators/StringOrNull.js";
+import "../../../../validators/index.js";
+import { RichTextNodeType, RichTextNodeTypeCodec } from "../../../../customtypes/widgets/nestable/RichText.js";
+import "../../../../customtypes/widgets/nestable/index.js";
+import { EmbedContent, EmbedContentLegacy, EmbedContentType } from "../EmbedContent.js";
+import { ImageContentView } from "../ImageContent.js";
+import { FilledLink, FilledLinkLegacy } from "../LinkContent.js";
+import * as t from "io-ts";
+import { either } from "fp-ts";
+import { withFallback } from "io-ts-types";
+import { isLeft } from "fp-ts/lib/Either";
+import { pipe } from "fp-ts/lib/function";
+
+//#region src/content/fields/nestable/RichTextContent/Blocks.ts
+const linkSpan = (linkCodec) => t.strict({
+	data: linkCodec,
+	start: t.number,
+	end: t.number,
+	type: t.literal(RichTextNodeType.hyperlink)
+});
+const labelSpan = t.strict({
+	data: withFallback(t.string, ""),
+	start: t.number,
+	end: t.number,
+	type: t.literal("label")
+});
+const basicSpan = t.strict({
+	start: t.number,
+	end: t.number,
+	type: t.keyof({
+		[RichTextNodeType.strong]: null,
+		[RichTextNodeType.em]: null,
+		"list-item": null
+	})
+});
+const Span = t.union([
+	linkSpan(FilledLink),
+	labelSpan,
+	basicSpan
+]);
+const SpanLegacy = t.union([
+	linkSpan(FilledLinkLegacy),
+	labelSpan,
+	basicSpan
+]);
+const ValidatedSpans = (spanCodec) => {
+	return new t.Type("ValidatedSpans", (spans) => Array.isArray(spans) && spans.every(spanCodec.is), (spans, c) => {
+		if (Array.isArray(spans)) {
+			const res = spans.reduce((acc, maybeSpan) => {
+				const decodedSpan = spanCodec.decode(maybeSpan);
+				if (isLeft(decodedSpan)) return acc;
+				return [...acc, decodedSpan.right];
+			}, []).sort((m1, m2) => m1.start - m2.start);
+			return t.success(res);
+		} else return t.failure(spans, c);
+	}, (m) => {
+		return m.reduce((acc, meta) => {
+			const encoded = spanCodec.encode(meta);
+			return [...acc, encoded];
+		}, []);
+	});
+};
+const ImageBlockCodec = (linkCodec) => t.exact(t.intersection([t.type({
+	type: t.literal(RichTextNodeType.image),
+	data: t.intersection([ImageContentView, t.partial({ linkTo: nullable(linkCodec) })])
+}), t.partial({
+	label: StringOrNull_default,
+	direction: StringOrNull_default
+})]));
+const ImageBlock = ImageBlockCodec(FilledLink);
+const ImageBlockLegacy = ImageBlockCodec(FilledLinkLegacy);
+function checkImageBlock(block) {
+	return block.type === RichTextNodeType.image;
+}
+const embedBlockLegacyCodec = t.exact(t.intersection([t.type({
+	type: t.literal(RichTextNodeType.embed),
+	data: t.unknown
+}), t.partial({
+	label: StringOrNull_default,
+	direction: StringOrNull_default
+})]));
+const EmbedBlockLegacy = new t.Type("EmbedBlockLegacy", (u) => u.type === "embed", (block) => pipe(embedBlockLegacyCodec.decode(block), either.chain((decodedBlock) => {
+	return either.map((decodedData) => {
+		return [decodedBlock, decodedData];
+	})(EmbedContentLegacy.decode(decodedBlock.data));
+}), either.map(([block, parsedData]) => {
+	return EmbedBlock.encode({
+		...block,
+		data: {
+			...parsedData,
+			__TYPE__: EmbedContentType,
+			all: block.data
+		}
+	});
+})), (embedBlock) => {
+	return {
+		...embedBlockLegacyCodec.encode(embedBlock),
+		data: EmbedContentLegacy.encode(embedBlock.data)
+	};
+});
+const EmbedBlock = t.exact(t.intersection([t.type({
+	type: t.literal(RichTextNodeType.embed),
+	data: EmbedContent
+}), t.partial({
+	label: StringOrNull_default,
+	direction: StringOrNull_default
+})]));
+function checkEmbedBlock(block) {
+	return block.type === RichTextNodeType.embed;
+}
+const TextBlockCodec = (spanCodec) => t.exact(t.intersection([t.type({
+	type: refineType(RichTextNodeTypeCodec, `string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`, (s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed),
+	content: t.intersection([t.type({ text: t.string }), t.partial({ spans: ValidatedSpans(spanCodec) })])
+}), t.partial({
+	label: t.string,
+	direction: t.string
+})]));
+const TextBlock = TextBlockCodec(Span);
+const TextBlockLegacy = TextBlockCodec(SpanLegacy);
+const legacyBlockCodec = t.union([
+	EmbedBlockLegacy,
+	ImageBlockLegacy,
+	TextBlockLegacy
+]);
+const BlockLegacy = new t.Type("BlockLegacy", (u) => EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u), (legacyBlock) => legacyBlockCodec.decode(legacyBlock), (block) => {
+	return (() => {
+		if (ImageBlock.is(block)) return ImageBlockLegacy.encode(block);
+		else if (EmbedBlock.is(block)) return EmbedBlockLegacy.encode(block);
+		else return TextBlockLegacy.encode(block);
+	})();
+});
+const Block = t.union([
+	ImageBlock,
+	EmbedBlock,
+	TextBlock
+]);
+
+//#endregion
+export { Block, BlockLegacy, EmbedBlock, ImageBlock, Span, SpanLegacy, TextBlock, TextBlockLegacy, ValidatedSpans, checkEmbedBlock, checkImageBlock };
+//# sourceMappingURL=Blocks.js.map

package/dist/content/fields/nestable/RichTextContent/Blocks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Blocks.js","names":["StringOrNull"],"sources":["../../../../../src/content/fields/nestable/RichTextContent/Blocks.ts"],"sourcesContent":["import { either } from \"fp-ts\"\nimport { isLeft } from \"fp-ts/lib/Either\"\nimport { pipe } from \"fp-ts/lib/function\"\nimport * as t from \"io-ts\"\nimport { withFallback } from \"io-ts-types\"\n\nimport { RichTextNodeType, RichTextNodeTypeCodec } from \"../../../../customtypes/widgets/nestable\"\nimport { StringOrNull } from \"../../../../validators\"\nimport { nullable, refineType } from \"../../../../validators/function\"\nimport type { EmbedLegacy } from \"../EmbedContent\";\nimport { EmbedContent, EmbedContentLegacy, EmbedContentType } from \"../EmbedContent\"\nimport { ImageContentView } from \"../ImageContent\"\nimport { FilledLink, FilledLinkLegacy } from \"../LinkContent\"\n\nconst linkSpan = (linkCodec: typeof FilledLink | typeof FilledLinkLegacy) =>\n\tt.strict({\n\t\tdata: linkCodec,\n\t\tstart: t.number,\n\t\tend: t.number,\n\t\ttype: t.literal(RichTextNodeType.hyperlink),\n\t})\n\nconst labelSpan = t.strict({\n\tdata: withFallback(t.string, \"\"),\n\tstart: t.number,\n\tend: t.number,\n\ttype: t.literal(\"label\"),\n})\n\nconst basicSpan = t.strict({\n\tstart: t.number,\n\tend: t.number,\n\ttype: t.keyof({\n\t\t[RichTextNodeType.strong]: null,\n\t\t[RichTextNodeType.em]: null,\n\t\t\"list-item\": null, // legacy case that should not happen, we shouldn't support this in new page builder or migration API\n\t}),\n})\n\nexport const Span = t.union([linkSpan(FilledLink), labelSpan, basicSpan])\nexport type Span = t.TypeOf<typeof Span>\n\nexport const SpanLegacy = t.union([linkSpan(FilledLinkLegacy), labelSpan, basicSpan])\nexport type SpanLegacy = t.TypeOf<typeof SpanLegacy>\n\nexport const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(spanCodec: C) => {\n\ttype S = t.TypeOf<C>\n\n\treturn new t.Type<S[], S[], unknown>(\n\t\t\"ValidatedSpans\",\n\t\t(spans): spans is S[] => Array.isArray(spans) && spans.every(spanCodec.is),\n\t\t(spans: unknown, c) => {\n\t\t\tif (Array.isArray(spans)) {\n\t\t\t\tconst res = spans\n\t\t\t\t\t.reduce<Array<S>>((acc, maybeSpan) => {\n\t\t\t\t\t\tconst decodedSpan = spanCodec.decode(maybeSpan)\n\t\t\t\t\t\tif (isLeft(decodedSpan)) return acc\n\t\t\t\t\t\treturn [...acc, decodedSpan.right]\n\t\t\t\t\t}, [])\n\t\t\t\t\t.sort((m1: S, m2: S) => m1.start - m2.start)\n\t\t\t\treturn t.success(res)\n\t\t\t} else return t.failure(spans, c)\n\t\t},\n\t\t(m) => {\n\t\t\treturn m.reduce<Array<S>>((acc, meta) => {\n\t\t\t\tconst encoded = <S>spanCodec.encode(meta)\n\t\t\t\treturn [...acc, encoded]\n\t\t\t}, [])\n\t\t},\n\t)\n}\n\n// We allow any codec here and let TypeScript infer the resulting codec.\n// Typing it more precisely creates conflicts.\n//\n// Using `t.Mixed` rather than `t.Type<A, O>` causes `data.linkTo` to be\n// typed as `any`. It seems to be an issue with the `nullable` helper.\nconst ImageBlockCodec = <A, O>(linkCodec: t.Type<A, O>) =>\n\tt.exact(\n\t\tt.intersection([\n\t\t\tt.type({\n\t\t\t\ttype: t.literal(RichTextNodeType.image),\n\t\t\t\tdata: t.intersection([\n\t\t\t\t\tImageContentView,\n\t\t\t\t\tt.partial({\n\t\t\t\t\t\tlinkTo: nullable(linkCodec),\n\t\t\t\t\t}),\n\t\t\t\t]),\n\t\t\t}),\n\t\t\tt.partial({\n\t\t\t\tlabel: StringOrNull,\n\t\t\t\tdirection: StringOrNull,\n\t\t\t}),\n\t\t]),\n\t)\n\nexport const ImageBlock = ImageBlockCodec(FilledLink)\nexport type ImageBlock = t.TypeOf<typeof ImageBlock>\n\nconst ImageBlockLegacy = ImageBlockCodec(FilledLinkLegacy)\ntype ImageBlockLegacy = t.TypeOf<typeof ImageBlockLegacy>\n\nexport function checkImageBlock(block: Block): block is ImageBlock {\n\treturn block.type === RichTextNodeType.image\n}\n\nconst embedBlockLegacyCodec = t.exact(\n\tt.intersection([\n\t\tt.type({\n\t\t\ttype: t.literal(RichTextNodeType.embed),\n\t\t\tdata: t.unknown,\n\t\t}),\n\t\tt.partial({\n\t\t\tlabel: StringOrNull,\n\t\t\tdirection: StringOrNull,\n\t\t}),\n\t]),\n)\n\ntype EmbedBlockLegacy = t.TypeOf<typeof embedBlockLegacyCodec>\n\nconst EmbedBlockLegacy = new t.Type<EmbedBlock, EmbedBlockLegacy, unknown>(\n\t\"EmbedBlockLegacy\",\n\t(u): u is EmbedBlock => (u as EmbedBlock).type === \"embed\",\n\t(block) =>\n\t\tpipe(\n\t\t\tembedBlockLegacyCodec.decode(block),\n\t\t\teither.chain((decodedBlock) => {\n\t\t\t\treturn either.map<EmbedLegacy, [EmbedBlockLegacy, EmbedLegacy]>(\n\t\t\t\t\t(decodedData: EmbedLegacy) => {\n\t\t\t\t\t\treturn [decodedBlock, decodedData]\n\t\t\t\t\t},\n\t\t\t\t)(EmbedContentLegacy.decode(decodedBlock.data))\n\t\t\t}),\n\t\t\teither.map(([block, parsedData]) => {\n\t\t\t\treturn EmbedBlock.encode({\n\t\t\t\t\t...block,\n\t\t\t\t\tdata: {\n\t\t\t\t\t\t...parsedData,\n\t\t\t\t\t\t__TYPE__: EmbedContentType,\n\t\t\t\t\t\tall: block.data,\n\t\t\t\t\t},\n\t\t\t\t})\n\t\t\t}),\n\t\t),\n\t(embedBlock: EmbedBlock): EmbedBlockLegacy => {\n\t\treturn {\n\t\t\t...embedBlockLegacyCodec.encode(embedBlock),\n\t\t\tdata: EmbedContentLegacy.encode(embedBlock.data),\n\t\t}\n\t},\n)\nexport const EmbedBlock = t.exact(\n\tt.intersection([\n\t\tt.type({\n\t\t\ttype: t.literal(RichTextNodeType.embed),\n\t\t\tdata: EmbedContent,\n\t\t}),\n\t\tt.partial({\n\t\t\tlabel: StringOrNull,\n\t\t\tdirection: StringOrNull,\n\t\t}),\n\t]),\n)\nexport type EmbedBlock = t.TypeOf<typeof EmbedBlock>\nexport function checkEmbedBlock(block: Block): block is EmbedBlock {\n\treturn block.type === RichTextNodeType.embed\n}\n\nconst TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(spanCodec: C) =>\n\tt.exact(\n\t\tt.intersection([\n\t\t\tt.type({\n\t\t\t\ttype: refineType(\n\t\t\t\t\tRichTextNodeTypeCodec,\n\t\t\t\t\t`string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`,\n\t\t\t\t\t(s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed,\n\t\t\t\t),\n\t\t\t\tcontent: t.intersection([\n\t\t\t\t\tt.type({\n\t\t\t\t\t\ttext: t.string,\n\t\t\t\t\t}),\n\t\t\t\t\tt.partial({\n\t\t\t\t\t\tspans: ValidatedSpans(spanCodec),\n\t\t\t\t\t}),\n\t\t\t\t]),\n\t\t\t}),\n\t\t\tt.partial({\n\t\t\t\tlabel: t.string,\n\t\t\t\tdirection: t.string,\n\t\t\t}),\n\t\t]),\n\t)\n\n/* These Text block will decode codec A and encode from codec B to A */\nexport const TextBlock = TextBlockCodec(Span)\nexport type TextBlock = t.TypeOf<typeof TextBlock>\n\nexport const TextBlockLegacy = TextBlockCodec(SpanLegacy)\nexport type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>\n\nconst legacyBlockCodec = t.union([EmbedBlockLegacy, ImageBlockLegacy, TextBlockLegacy])\ntype BlockLegacy = t.TypeOf<typeof legacyBlockCodec>\n\nexport const BlockLegacy = new t.Type<Block, BlockLegacy, unknown>(\n\t\"BlockLegacy\",\n\t(u): u is Block => EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u),\n\t(legacyBlock) => legacyBlockCodec.decode(legacyBlock),\n\t(block: Block) => {\n\t\treturn (() => {\n\t\t\tif (ImageBlock.is(block)) return ImageBlockLegacy.encode(block)\n\t\t\telse if (EmbedBlock.is(block)) return EmbedBlockLegacy.encode(block)\n\t\t\telse return TextBlockLegacy.encode(block)\n\t\t})() as BlockLegacy\n\t},\n)\nexport const Block = t.union([ImageBlock, EmbedBlock, TextBlock])\nexport type Block = t.TypeOf<typeof Block>\n"],"mappings":"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"}

package/dist/content/fields/nestable/RichTextContent/index.cjs

@@ -0,0 +1,37 @@
+const require_runtime = require('../../../../_virtual/_rolldown/runtime.cjs');
+const require_helpers = require('../../../helpers.cjs');
+require('../../../utils.cjs');
+const require_Blocks = require('./Blocks.cjs');
+let io_ts = require("io-ts");
+io_ts = require_runtime.__toESM(io_ts);
+let fp_ts = require("fp-ts");
+let fp_ts_lib_function = require("fp-ts/lib/function");
+
+//#region src/content/fields/nestable/RichTextContent/index.ts
+const RichTextContentType = "StructuredTextContent";
+const isRichTextContent = (u) => require_helpers.hasContentType(u) && u.__TYPE__ === RichTextContentType;
+const RichTextLegacyContent = io_ts.array(require_Blocks.BlockLegacy);
+const RichTextContent = io_ts.strict({
+	__TYPE__: io_ts.literal(RichTextContentType),
+	value: io_ts.array(require_Blocks.Block)
+});
+const RichTextLegacy = (ctx) => new io_ts.Type("RichTextLegacy", isRichTextContent, (u) => {
+	return (0, fp_ts_lib_function.pipe)(RichTextLegacyContent.decode(u), fp_ts.either.map((r) => ({
+		value: r,
+		__TYPE__: RichTextContentType
+	})));
+}, (r) => {
+	return {
+		content: RichTextLegacyContent.encode(r.value),
+		types: { [ctx.keyOfType]: "StructuredText" },
+		keys: {}
+	};
+});
+
+//#endregion
+exports.RichTextContent = RichTextContent;
+exports.RichTextContentType = RichTextContentType;
+exports.RichTextLegacy = RichTextLegacy;
+exports.RichTextLegacyContent = RichTextLegacyContent;
+exports.isRichTextContent = isRichTextContent;
+//# sourceMappingURL=index.cjs.map

package/dist/content/fields/nestable/RichTextContent/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["hasContentType","t","BlockLegacy","Block","either"],"sources":["../../../../../src/content/fields/nestable/RichTextContent/index.ts"],"sourcesContent":["import { either } from \"fp-ts\"\nimport { pipe } from \"fp-ts/lib/function\"\nimport * as t from \"io-ts\"\n\nimport type { LegacyContentCtx, WithTypes } from \"../../../LegacyContentCtx\"\nimport { hasContentType } from \"../../../utils\"\nimport { Block, BlockLegacy } from \"./Blocks\"\n\nexport const RichTextContentType = \"StructuredTextContent\"\nexport const isRichTextContent = (u: unknown): u is RichTextContent =>\n\thasContentType(u) && u.__TYPE__ === RichTextContentType\n\nexport const RichTextLegacyContent = t.array(BlockLegacy)\ntype RichTextLegacyContent = t.TypeOf<typeof RichTextLegacyContent>\n\nexport const RichTextContent = t.strict({\n\t__TYPE__: t.literal(RichTextContentType),\n\tvalue: t.array(Block),\n})\nexport type RichTextContent = t.TypeOf<typeof RichTextContent>\n\nexport * from \"./Blocks\"\n\nexport const RichTextLegacy = (ctx: LegacyContentCtx) =>\n\tnew t.Type<RichTextContent, WithTypes<RichTextLegacyContent>, unknown>(\n\t\t\"RichTextLegacy\",\n\t\tisRichTextContent,\n\t\t(u) => {\n\t\t\treturn pipe(\n\t\t\t\tRichTextLegacyContent.decode(u),\n\t\t\t\teither.map((r) => ({ value: r, __TYPE__: RichTextContentType })),\n\t\t\t)\n\t\t},\n\n\t\t(r: RichTextContent): WithTypes<RichTextLegacyContent> => {\n\t\t\treturn {\n\t\t\t\tcontent: RichTextLegacyContent.encode(r.value),\n\t\t\t\ttypes: { [ctx.keyOfType]: \"StructuredText\" },\n\t\t\t\tkeys: {},\n\t\t\t}\n\t\t},\n\t)\n"],"mappings":";;;;;;;;;;AAQA,MAAa,sBAAsB;AACnC,MAAa,qBAAqB,MACjCA,+BAAe,EAAE,IAAI,EAAE,aAAa;AAErC,MAAa,wBAAwBC,MAAE,MAAMC,2BAAY;AAGzD,MAAa,kBAAkBD,MAAE,OAAO;CACvC,UAAUA,MAAE,QAAQ,oBAAoB;CACxC,OAAOA,MAAE,MAAME,qBAAM;CACrB,CAAC;AAKF,MAAa,kBAAkB,QAC9B,IAAIF,MAAE,KACL,kBACA,oBACC,MAAM;AACN,qCACC,sBAAsB,OAAO,EAAE,EAC/BG,aAAO,KAAK,OAAO;EAAE,OAAO;EAAG,UAAU;EAAqB,EAAE,CAChE;IAGD,MAAyD;AACzD,QAAO;EACN,SAAS,sBAAsB,OAAO,EAAE,MAAM;EAC9C,OAAO,GAAG,IAAI,YAAY,kBAAkB;EAC5C,MAAM,EAAE;EACR;EAEF"}