@prismicio/types-internal 0.2.2 → 0.2.3

package/lib/documents/widgets/nestable/index.js

@@ -1,29 +1,40 @@
-import { BooleanContentType } from "./BooleanContent";
-import { EmbedContentType } from "./EmbedContent";
-import { FieldContentType } from "./FieldContent";
-import { GeoPointContentType } from "./GeoPointContent";
-import { ImageContentType } from "./ImageContent";
-import { IntegrationFieldsContentType } from "./IntegrationFieldsContent";
-import { LinksTypes } from "./Link";
-import { SeparatorContentType } from "./SeparatorContent";
-import { StructuredTextContentType } from "./StructuredTextContent";
-export { default as BooleanContent } from "./BooleanContent";
-export { default as EmbedContent } from "./EmbedContent";
-export { default as FieldContent } from "./FieldContent";
-export { GeoPointContent } from "./GeoPointContent";
-export { ImageContent, ImageContentView, } from "./ImageContent";
-export { default as IntegrationFieldsContent } from "./IntegrationFieldsContent";
-export * as Links from "./Link";
-export * from "./SeparatorContent";
-export * from "./StructuredTextContent";
-export const NestableTypes = {
-    Links: LinksTypes,
-    StructuredText: StructuredTextContentType,
-    Boolean: BooleanContentType,
-    Embed: EmbedContentType,
-    Field: FieldContentType,
-    GeoPoint: GeoPointContentType,
-    Image: ImageContentType,
-    IntegrationFields: IntegrationFieldsContentType,
-    Separator: SeparatorContentType,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestableTypes = exports.Links = exports.IntegrationFieldsContent = exports.ImageContentView = exports.ImageContent = exports.GeoPointContent = exports.FieldContent = exports.EmbedContent = exports.BooleanContent = void 0;
+const tslib_1 = require("tslib");
+const BooleanContent_1 = require("./BooleanContent");
+const EmbedContent_1 = require("./EmbedContent");
+const FieldContent_1 = require("./FieldContent");
+const GeoPointContent_1 = require("./GeoPointContent");
+const ImageContent_1 = require("./ImageContent");
+const IntegrationFieldsContent_1 = require("./IntegrationFieldsContent");
+const Link_1 = require("./Link");
+const SeparatorContent_1 = require("./SeparatorContent");
+const StructuredTextContent_1 = require("./StructuredTextContent");
+var BooleanContent_2 = require("./BooleanContent");
+Object.defineProperty(exports, "BooleanContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(BooleanContent_2).default; } });
+var EmbedContent_2 = require("./EmbedContent");
+Object.defineProperty(exports, "EmbedContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(EmbedContent_2).default; } });
+var FieldContent_2 = require("./FieldContent");
+Object.defineProperty(exports, "FieldContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(FieldContent_2).default; } });
+var GeoPointContent_2 = require("./GeoPointContent");
+Object.defineProperty(exports, "GeoPointContent", { enumerable: true, get: function () { return GeoPointContent_2.GeoPointContent; } });
+var ImageContent_2 = require("./ImageContent");
+Object.defineProperty(exports, "ImageContent", { enumerable: true, get: function () { return ImageContent_2.ImageContent; } });
+Object.defineProperty(exports, "ImageContentView", { enumerable: true, get: function () { return ImageContent_2.ImageContentView; } });
+var IntegrationFieldsContent_2 = require("./IntegrationFieldsContent");
+Object.defineProperty(exports, "IntegrationFieldsContent", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(IntegrationFieldsContent_2).default; } });
+exports.Links = (0, tslib_1.__importStar)(require("./Link"));
+(0, tslib_1.__exportStar)(require("./SeparatorContent"), exports);
+(0, tslib_1.__exportStar)(require("./StructuredTextContent"), exports);
+exports.NestableTypes = {
+    Links: Link_1.LinksTypes,
+    StructuredText: StructuredTextContent_1.StructuredTextContentType,
+    Boolean: BooleanContent_1.BooleanContentType,
+    Embed: EmbedContent_1.EmbedContentType,
+    Field: FieldContent_1.FieldContentType,
+    GeoPoint: GeoPointContent_1.GeoPointContentType,
+    Image: ImageContent_1.ImageContentType,
+    IntegrationFields: IntegrationFieldsContent_1.IntegrationFieldsContentType,
+    Separator: SeparatorContent_1.SeparatorContentType,
 };

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

@@ -1,22 +1,26 @@
-import { isRight } from "fp-ts/Either";
-import * as O from "fp-ts/Option";
-import * as t from "io-ts";
-import { GroupContent, SimpleWidgetContent } from "../index";
-export const CompositeSliceContentType = "CompositeSliceContent";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeSliceContent = exports.CompositeSliceContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const index_1 = require("../index");
+exports.CompositeSliceContentType = "CompositeSliceContent";
 const codec = t.exact(t.partial({
     repeat: t.array(t.unknown),
     "non-repeat": t.UnknownRecord,
 }));
-export const CompositeSliceContent = {
+exports.CompositeSliceContent = {
     fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
         const prefixedRepeatKey = Array.of(prefixes, [key, "repeat"])
             .flat()
             .join(".");
         const decodedValue = codec.decode(value);
-        if (isRight(decodedValue)) {
+        if ((0, Either_1.isRight)(decodedValue)) {
             const repeatObj = decodedValue.right.repeat;
             const nonRepeatObj = decodedValue.right["non-repeat"] ?? {};
-            const groupItemsContentsRepeat = GroupContent.itemsContentsFromJson(prefixedRepeatKey, repeatObj, fieldTypes, fieldPositions);
+            const groupItemsContentsRepeat = index_1.GroupContent.itemsContentsFromJson(prefixedRepeatKey, repeatObj, fieldTypes, fieldPositions);
             const sortedFields = Object.entries(nonRepeatObj).sort(([k1], [k2]) => {
                 const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
                 const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
@@ -26,7 +30,7 @@ export const CompositeSliceContent = {
                 const kp = Array.of(prefixes, [key, "non-repeat", k]).flat().join(".");
                 const kind = fieldTypes.get(kp);
                 if (kind) {
-                    const mWidgetContent = SimpleWidgetContent.from(kind, v);
+                    const mWidgetContent = index_1.SimpleWidgetContent.from(kind, v);
                     if (O.isSome(mWidgetContent)) {
                         acc[k] = mWidgetContent.value;
                     }

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

@@ -1,17 +1,21 @@
-import { map } from "fp-ts/Either";
-import * as O from "fp-ts/Option";
-import * as t from "io-ts";
-import { withFallback } from "io-ts-types";
-import { GroupContent, SimpleWidgetContent } from "../index";
-export const SharedSliceContentType = "SharedSliceContent";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedSliceContent = exports.SharedSliceContentType = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const io_ts_types_1 = require("io-ts-types");
+const index_1 = require("../index");
+exports.SharedSliceContentType = "SharedSliceContent";
 const codec = t.exact(t.type({
     variation: t.string,
-    items: withFallback(t.array(t.unknown), []),
-    primary: withFallback(t.UnknownRecord, {}),
+    items: (0, io_ts_types_1.withFallback)(t.array(t.unknown), []),
+    primary: (0, io_ts_types_1.withFallback)(t.UnknownRecord, {}),
 }));
-export const SharedSliceContent = {
+exports.SharedSliceContent = {
     fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
-        const r = map((v) => {
+        const r = (0, Either_1.map)((v) => {
             const prefixedItemsKey = Array.of(prefixes, [
                 key,
                 "variations",
@@ -20,7 +24,7 @@ export const SharedSliceContent = {
             ])
                 .flat()
                 .join(".");
-            const groupItemsContents = GroupContent.itemsContentsFromJson(prefixedItemsKey, v.items, fieldTypes, fieldPositions);
+            const groupItemsContents = index_1.GroupContent.itemsContentsFromJson(prefixedItemsKey, v.items, fieldTypes, fieldPositions);
             const sortedFields = Object.entries(v.primary).sort(([k1], [k2]) => {
                 const p1 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k1}`) ?? 10000;
                 const p2 = fieldPositions.get(`${Array.of(prefixes, [key]).flat().join(".")}.${k2}`) ?? 10000;
@@ -38,7 +42,7 @@ export const SharedSliceContent = {
                     .join(".");
                 const kind = fieldTypes.get(kp);
                 if (kind) {
-                    const maybeWidgetContent = SimpleWidgetContent.from(kind, w);
+                    const maybeWidgetContent = index_1.SimpleWidgetContent.from(kind, w);
                     if (O.isSome(maybeWidgetContent)) {
                         acc[k] = maybeWidgetContent.value;
                     }

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

@@ -1,2 +1,6 @@
-import StaticWidgetContent from "../StaticWidgetContent";
-export const SimpleSliceContent = StaticWidgetContent;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleSliceContent = void 0;
+const tslib_1 = require("tslib");
+const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("../StaticWidgetContent"));
+exports.SimpleSliceContent = StaticWidgetContent_1.default;

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

@@ -1,19 +1,23 @@
-import * as O from "fp-ts/Option";
-import StaticWidgetContent from "../StaticWidgetContent";
-import { CompositeSliceContent } from "./CompositeSliceContent";
-import { SharedSliceContent } from "./SharedSliceContent";
-export const SliceWidgetContent = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SliceWidgetContent = void 0;
+const tslib_1 = require("tslib");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const StaticWidgetContent_1 = (0, tslib_1.__importDefault)(require("../StaticWidgetContent"));
+const CompositeSliceContent_1 = require("./CompositeSliceContent");
+const SharedSliceContent_1 = require("./SharedSliceContent");
+exports.SliceWidgetContent = {
     fromJson: (prefixes, key, value, fieldTypes, fieldPositions) => {
         const prefixedKey = Array.of(prefixes, [key]).flat().join(".");
         const fieldType = fieldTypes.get(prefixedKey);
         if (fieldType === "SharedSlice") {
-            return SharedSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+            return SharedSliceContent_1.SharedSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
         }
         else if (fieldType === "Slice") {
-            return CompositeSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+            return CompositeSliceContent_1.CompositeSliceContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
         }
         else if (fieldType) {
-            return StaticWidgetContent.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
+            return StaticWidgetContent_1.default.fromJson(prefixes, key, value, fieldTypes, fieldPositions);
         }
         else {
             return O.none;

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

@@ -1,22 +1,26 @@
-import * as A from "fp-ts/Array";
-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 { SliceWidgetContent } from "./SliceWidgetContent";
-export const SlicesContentType = "SliceContentType";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicesContent = 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");
+const O = (0, tslib_1.__importStar)(require("fp-ts/Option"));
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_2 = require("../../../validators/function");
+const SliceWidgetContent_1 = require("./SliceWidgetContent");
+exports.SlicesContentType = "SliceContentType";
 const codec = t.exact(t.intersection([
     t.type({
         key: t.string,
         value: t.unknown,
     }),
     t.partial({
-        label: nullable(t.string),
+        label: (0, function_2.nullable)(t.string),
     }),
 ]));
-export const SlicesContent = {
+exports.SlicesContent = {
     itemsCodec: (value, codecWidget) => {
-        return pipe(codec.decode(value), O.fromEither, O.chain((r) => {
+        return (0, function_1.pipe)(codec.decode(value), O.fromEither, O.chain((r) => {
             const stopIdx = r.key.indexOf("$");
             const name = r.key.substring(0, stopIdx > 0 ? stopIdx : undefined);
             const maybeWidget = codecWidget(name, r.value);
@@ -33,10 +37,10 @@ export const SlicesContent = {
     fromJson: (key, value, fieldTypes, fieldPositions) => {
         if (fieldTypes.get(key) === "Slices") {
             const jsItems = O.getOrElse(() => new Array())(O.fromEither(t.array(t.unknown).decode(value)));
-            const widgetCodec = (name, wValue) => SliceWidgetContent.fromJson([key], name, wValue, fieldTypes, fieldPositions);
+            const widgetCodec = (name, wValue) => SliceWidgetContent_1.SliceWidgetContent.fromJson([key], name, wValue, fieldTypes, fieldPositions);
             return O.some({
-                value: A.compact(jsItems.map((jsItem) => SlicesContent.itemsCodec(jsItem, widgetCodec))),
-                __TYPE__: SlicesContentType,
+                value: A.compact(jsItems.map((jsItem) => exports.SlicesContent.itemsCodec(jsItem, widgetCodec))),
+                __TYPE__: exports.SlicesContentType,
             });
         }
         else {

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

@@ -1,5 +1,8 @@
-export * from "./CompositeSliceContent";
-export * from "./SharedSliceContent";
-export * from "./SimpleSliceContent";
-export * from "./SlicesContent";
-export * from "./SliceWidgetContent";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./CompositeSliceContent"), exports);
+(0, tslib_1.__exportStar)(require("./SharedSliceContent"), exports);
+(0, tslib_1.__exportStar)(require("./SimpleSliceContent"), exports);
+(0, tslib_1.__exportStar)(require("./SlicesContent"), exports);
+(0, tslib_1.__exportStar)(require("./SliceWidgetContent"), exports);

package/lib/index.js

@@ -1,3 +1,7 @@
-export * as CustomTypes from "./customtypes";
-export * as Documents from "./documents";
-export * as Validators from "./validators";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validators = exports.Documents = exports.CustomTypes = void 0;
+const tslib_1 = require("tslib");
+exports.CustomTypes = (0, tslib_1.__importStar)(require("./customtypes"));
+exports.Documents = (0, tslib_1.__importStar)(require("./documents"));
+exports.Validators = (0, tslib_1.__importStar)(require("./validators"));

package/lib/validators/DateFromString.js

@@ -1,7 +1,10 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
-export default new t.Type("dateFromString", (u) => u instanceof Date, (u, c) => pipe(t.string.validate(u, c), chain((s) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.default = new t.Type("dateFromString", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(t.string.validate(u, c), (0, Either_1.chain)((s) => {
     const d = new Date(s);
     return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
 })), (date) => date.toISOString());

package/lib/validators/DateFromStringOrNumber.js

@@ -1,7 +1,10 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
-export default new t.Type("dateFromStringOrNumber", (u) => u instanceof Date, (u, c) => pipe(t.union([t.number, t.string]).validate(u, c), chain((s) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.default = new t.Type("dateFromStringOrNumber", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(t.union([t.number, t.string]).validate(u, c), (0, Either_1.chain)((s) => {
     const d = new Date(s);
     return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
 })), (date) => date);

package/lib/validators/DateFromTsMs.js

@@ -1,7 +1,10 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
-export default new t.Type("dateFromTsMs", (u) => u instanceof Date, (u, c) => pipe(t.number.validate(u, c), chain((s) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+exports.default = new t.Type("dateFromTsMs", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((s) => {
     const d = new Date(s);
     return isNaN(d.getTime()) ? t.failure(u, c) : t.success(d);
 })), (date) => date.getTime());

package/lib/validators/IntFromNumber.js

@@ -1,8 +1,11 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
 /** A codec that succeeds if a number can be parsed to an integer */
-export default new t.Type("IntFromNumber", t.Int.is, (u, c) => pipe(t.number.validate(u, c), chain((n) => {
+exports.default = new t.Type("IntFromNumber", t.Int.is, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((n) => {
     if (t.Int.is(n))
         return t.success(n);
     else {

package/lib/validators/IntFromPixels.js

@@ -1,12 +1,15 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
 const PixelsRegex = /^([0-9]+)px$/;
 /**
  * A codec that succeeds if a string representing pixels (eg: "200px") can be
  * parsed to an integer
  */
-export default new t.Type("IntFromPixels", t.Int.is, (u, c) => pipe(t.string.validate(u, c), chain((strPixels) => {
+exports.default = new t.Type("IntFromPixels", t.Int.is, (u, c) => (0, function_1.pipe)(t.string.validate(u, c), (0, Either_1.chain)((strPixels) => {
     try {
         const matched = strPixels.match(PixelsRegex);
         if (!matched)

package/lib/validators/NonEmptyString.js

@@ -1,3 +1,6 @@
-import * as t from "io-ts";
-import { refineType } from "./function";
-export default refineType(t.string, "nonEmptyString", (s) => s.trim().length > 0);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("./function");
+exports.default = (0, function_1.refineType)(t.string, "nonEmptyString", (s) => s.trim().length > 0);

package/lib/validators/NonEmptyStringOrNull.js

@@ -1,12 +1,15 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import { success, Type } from "io-ts";
-import StringOrNull from "./StringOrNull";
-export default new Type("nonEmptyStringOrNull", (u) => typeof u === "string" || u === null, (u, c) => pipe(StringOrNull.validate(u, c), chain((s) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const io_ts_1 = require("io-ts");
+const StringOrNull_1 = (0, tslib_1.__importDefault)(require("./StringOrNull"));
+exports.default = new io_ts_1.Type("nonEmptyStringOrNull", (u) => typeof u === "string" || u === null, (u, c) => (0, function_1.pipe)(StringOrNull_1.default.validate(u, c), (0, Either_1.chain)((s) => {
     if (typeof s === "string" && s.length > 0) {
-        return success(s);
+        return (0, io_ts_1.success)(s);
     }
     else {
-        return success(null);
+        return (0, io_ts_1.success)(null);
     }
 })), (s) => s);

package/lib/validators/NumberOrNull.js

@@ -1,3 +1,6 @@
-import * as t from "io-ts";
-import { nullable } from "./function";
-export default nullable(t.number);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("./function");
+exports.default = (0, function_1.nullable)(t.number);

package/lib/validators/StringFromBoolean.js

@@ -1,7 +1,10 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
 /** A codec that validates a Boolean and convert it as a string */
-export default new t.Type("StringFromInt", t.string.is, (u, c) => pipe(t.boolean.validate(u, c), chain((i) => {
+exports.default = new t.Type("StringFromInt", t.string.is, (u, c) => (0, function_1.pipe)(t.boolean.validate(u, c), (0, Either_1.chain)((i) => {
     return t.success(i.toString());
 })), (i) => i);

package/lib/validators/StringFromNumber.js

@@ -1,7 +1,10 @@
-import { chain } from "fp-ts/Either";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const Either_1 = require("fp-ts/Either");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
 /** A codec that validates a number and convert it as a string */
-export default new t.Type("StringFromInt", t.string.is, (u, c) => pipe(t.number.validate(u, c), chain((i) => {
+exports.default = new t.Type("StringFromInt", t.string.is, (u, c) => (0, function_1.pipe)(t.number.validate(u, c), (0, Either_1.chain)((i) => {
     return t.success(i.toString());
 })), (i) => i);

package/lib/validators/StringOrNull.js

@@ -1,3 +1,6 @@
-import * as t from "io-ts";
-import { nullable } from "./function";
-export default nullable(t.string);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("./function");
+exports.default = (0, function_1.nullable)(t.string);

package/lib/validators/function.js

@@ -1,27 +1,36 @@
-import { either } from "fp-ts";
-import { pipe } from "fp-ts/function";
-import * as t from "io-ts";
-import { mapOutput } from "io-ts-types/mapOutput";
-export function nullable(c) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addType = exports.isEmpty = exports.objectToMap = exports.grouped = exports.formatDate = exports.formatDateTime = exports.filterDouble = exports.refineType = exports.nullable = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const mapOutput_1 = require("io-ts-types/mapOutput");
+function nullable(c) {
     return t.union([c, t.null, t.undefined]);
 }
-export function refineType(type, newName, pred) {
-    return new t.Type(newName, type.is, (u, c) => pipe(type.validate(u, c), either.chain((v) => (pred(v) ? t.success(v) : t.failure(u, c)))), type.encode);
+exports.nullable = nullable;
+function refineType(type, newName, pred) {
+    return new t.Type(newName, type.is, (u, c) => (0, function_1.pipe)(type.validate(u, c), fp_ts_1.either.chain((v) => (pred(v) ? t.success(v) : t.failure(u, c)))), type.encode);
 }
-export function filterDouble(value) {
+exports.refineType = refineType;
+function filterDouble(value) {
     if (value === "") {
         return null;
     }
     const result = Number(value);
     return Number.isNaN(result) ? null : result;
 }
-export function formatDateTime(date) {
+exports.filterDouble = filterDouble;
+function formatDateTime(date) {
     return date.toISOString().replace(/\.\d{3}Z$/, "+0000");
 }
-export function formatDate(date) {
+exports.formatDateTime = formatDateTime;
+function formatDate(date) {
     return date.toISOString().replace(/T.*/, "");
 }
-export function grouped(array, n) {
+exports.formatDate = formatDate;
+function grouped(array, n) {
     return array.reduce((acc, curr, idx) => {
         if (idx % n === 0) {
             acc.push([curr]);
@@ -33,15 +42,19 @@ export function grouped(array, n) {
         return acc;
     }, new Array());
 }
-export function objectToMap(object) {
+exports.grouped = grouped;
+function objectToMap(object) {
     return new Map(Object.entries(object));
 }
-export function isEmpty(obj) {
+exports.objectToMap = objectToMap;
+function isEmpty(obj) {
     for (const _x in obj) {
         return false;
     }
     return true;
 }
-export function addType(codec, t) {
-    return mapOutput(codec, (o) => ({ ...o, __TYPE__: t }));
+exports.isEmpty = isEmpty;
+function addType(codec, t) {
+    return (0, mapOutput_1.mapOutput)(codec, (o) => ({ ...o, __TYPE__: t }));
 }
+exports.addType = addType;

package/lib/validators/index.js

@@ -1,12 +1,27 @@
-export { default as DateFromString } from "./DateFromString";
-export { default as DateFromStringOrNumber } from "./DateFromStringOrNumber";
-export { default as DateFromTsMs } from "./DateFromTsMs";
-export * as Function from "./function";
-export { default as IntFromNumber } from "./IntFromNumber";
-export { default as IntFromPixels } from "./IntFromPixels";
-export { default as NonEmptyString } from "./NonEmptyString";
-export { default as NonEmptyStringOrNull } from "./NonEmptyStringOrNull";
-export { default as NumberOrNull } from "./NumberOrNull";
-export { default as StringFromBoolean } from "./StringFromBoolean";
-export { default as StringFromNumber } from "./StringFromNumber";
-export { default as StringOrNull } from "./StringOrNull";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringOrNull = exports.StringFromNumber = exports.StringFromBoolean = exports.NumberOrNull = exports.NonEmptyStringOrNull = exports.NonEmptyString = exports.IntFromPixels = exports.IntFromNumber = exports.Function = exports.DateFromTsMs = exports.DateFromStringOrNumber = exports.DateFromString = void 0;
+const tslib_1 = require("tslib");
+var DateFromString_1 = require("./DateFromString");
+Object.defineProperty(exports, "DateFromString", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(DateFromString_1).default; } });
+var DateFromStringOrNumber_1 = require("./DateFromStringOrNumber");
+Object.defineProperty(exports, "DateFromStringOrNumber", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(DateFromStringOrNumber_1).default; } });
+var DateFromTsMs_1 = require("./DateFromTsMs");
+Object.defineProperty(exports, "DateFromTsMs", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(DateFromTsMs_1).default; } });
+exports.Function = (0, tslib_1.__importStar)(require("./function"));
+var IntFromNumber_1 = require("./IntFromNumber");
+Object.defineProperty(exports, "IntFromNumber", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(IntFromNumber_1).default; } });
+var IntFromPixels_1 = require("./IntFromPixels");
+Object.defineProperty(exports, "IntFromPixels", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(IntFromPixels_1).default; } });
+var NonEmptyString_1 = require("./NonEmptyString");
+Object.defineProperty(exports, "NonEmptyString", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NonEmptyString_1).default; } });
+var NonEmptyStringOrNull_1 = require("./NonEmptyStringOrNull");
+Object.defineProperty(exports, "NonEmptyStringOrNull", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NonEmptyStringOrNull_1).default; } });
+var NumberOrNull_1 = require("./NumberOrNull");
+Object.defineProperty(exports, "NumberOrNull", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NumberOrNull_1).default; } });
+var StringFromBoolean_1 = require("./StringFromBoolean");
+Object.defineProperty(exports, "StringFromBoolean", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(StringFromBoolean_1).default; } });
+var StringFromNumber_1 = require("./StringFromNumber");
+Object.defineProperty(exports, "StringFromNumber", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(StringFromNumber_1).default; } });
+var StringOrNull_1 = require("./StringOrNull");
+Object.defineProperty(exports, "StringOrNull", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(StringOrNull_1).default; } });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "0.2.2",
+	"version": "0.2.3",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

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

@@ -2,9 +2,8 @@ import * as t from "io-ts"
 
 import Group from "../Group"
 import NestableWidget from "../nestable/NestableWidget"
-import UID from "../UID"
 
-const LegacySlice = t.union([UID, NestableWidget, Group])
+const LegacySlice = t.union([NestableWidget, Group])
 
 type LegacySlice = t.TypeOf<typeof LegacySlice>