@prismicio/types-internal 0.1.1 → 0.2.3

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

@@ -0,0 +1,17 @@
+import * as O from "fp-ts/Option";
+import { SliceWidgetContent } from "./SliceWidgetContent";
+export declare type SlicesContentItem = {
+    key: string;
+    name: string;
+    maybeLabel: string | undefined;
+    widget: SliceWidgetContent;
+};
+export declare const SlicesContentType = "SliceContentType";
+export declare type SlicesContent = {
+    __TYPE__: typeof SlicesContentType;
+    value: SlicesContentItem[];
+};
+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

@@ -0,0 +1,51 @@
+"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: (0, function_2.nullable)(t.string),
+    }),
+]));
+exports.SlicesContent = {
+    itemsCodec: (value, codecWidget) => {
+        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);
+            return O.map((widget) => {
+                return {
+                    key: r.key,
+                    name,
+                    maybeLabel: r.label ?? undefined,
+                    widget: widget,
+                };
+            })(maybeWidget);
+        }));
+    },
+    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_1.SliceWidgetContent.fromJson([key], name, wValue, fieldTypes, fieldPositions);
+            return O.some({
+                value: A.compact(jsItems.map((jsItem) => exports.SlicesContent.itemsCodec(jsItem, widgetCodec))),
+                __TYPE__: exports.SlicesContentType,
+            });
+        }
+        else {
+            console.error("fieldTypes.get(key) !== 'Slices'");
+            return O.none;
+        }
+    },
+};

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

@@ -0,0 +1,5 @@
+export * from "./CompositeSliceContent";
+export * from "./SharedSliceContent";
+export * from "./SimpleSliceContent";
+export * from "./SlicesContent";
+export * from "./SliceWidgetContent";

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

@@ -0,0 +1,8 @@
+"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.d.ts

@@ -0,0 +1,3 @@
+export * as CustomTypes from "./customtypes";
+export * as Documents from "./documents";
+export * as Validators from "./validators";

package/lib/index.js

@@ -0,0 +1,7 @@
+"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.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, string, unknown>;
+export default _default;

package/lib/validators/DateFromString.js

@@ -0,0 +1,10 @@
+"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.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, Date, unknown>;
+export default _default;

package/lib/validators/DateFromStringOrNumber.js

@@ -0,0 +1,10 @@
+"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.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<Date, number, unknown>;
+export default _default;

package/lib/validators/DateFromTsMs.js

@@ -0,0 +1,10 @@
+"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.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type IntFromNumberC = t.Type<t.Int, number, unknown>;
+declare const _default: t.Type<t.Int, number, unknown>;
+/** A codec that succeeds if a number can be parsed to an integer */
+export default _default;

package/lib/validators/IntFromNumber.js

@@ -0,0 +1,14 @@
+"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 */
+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 {
+        return t.success(Math.round(n));
+    }
+})), t.Int.encode);

package/lib/validators/IntFromPixels.d.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts";
+export declare type IntFromPixelsC = t.Type<t.Int, string, unknown>;
+declare const _default: t.Type<t.Int, string, unknown>;
+/**
+ * A codec that succeeds if a string representing pixels (eg: "200px") can be
+ * parsed to an integer
+ */
+export default _default;

package/lib/validators/IntFromPixels.js

@@ -0,0 +1,24 @@
+"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
+ */
+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)
+            return t.failure(u, c);
+        /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+        const parsed = parseInt(matched[1]);
+        return t.success(parsed);
+    }
+    catch {
+        return t.failure(u, c);
+    }
+})), String);

package/lib/validators/NonEmptyString.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.Type<string, string, unknown>;
+export default _default;

package/lib/validators/NonEmptyString.js

@@ -0,0 +1,6 @@
+"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.d.ts

@@ -0,0 +1,3 @@
+import { Type } from "io-ts";
+declare const _default: Type<string | null, string | null, unknown>;
+export default _default;

package/lib/validators/NonEmptyStringOrNull.js

@@ -0,0 +1,15 @@
+"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 (0, io_ts_1.success)(s);
+    }
+    else {
+        return (0, io_ts_1.success)(null);
+    }
+})), (s) => s);

package/lib/validators/NumberOrNull.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.UnionC<[t.Type<number, number, unknown>, t.NullC, t.UndefinedC]>;
+export default _default;

package/lib/validators/NumberOrNull.js

@@ -0,0 +1,6 @@
+"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.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type StringFromBooleanC = t.Type<string, string, unknown>;
+declare const _default: t.Type<string, string, unknown>;
+/** A codec that validates a Boolean and convert it as a string */
+export default _default;

package/lib/validators/StringFromBoolean.js

@@ -0,0 +1,10 @@
+"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 */
+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.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type StringFromNumberC = t.Type<string, string, unknown>;
+declare const _default: t.Type<string, string, unknown>;
+/** A codec that validates a number and convert it as a string */
+export default _default;

package/lib/validators/StringFromNumber.js

@@ -0,0 +1,10 @@
+"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 */
+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.d.ts

@@ -0,0 +1,3 @@
+import * as t from "io-ts";
+declare const _default: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+export default _default;

package/lib/validators/StringOrNull.js

@@ -0,0 +1,6 @@
+"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.d.ts

@@ -0,0 +1,14 @@
+import * as t from "io-ts";
+export declare function nullable<A, O>(c: t.Type<A, O>): t.UnionC<[t.Type<A, O, unknown>, t.NullC, t.UndefinedC]>;
+export declare function refineType<A, O, I>(type: t.Type<A, O, I>, newName: string, pred: (a: A) => boolean): t.Type<A, O, I>;
+export declare function filterDouble(value: string): number | null;
+export declare function formatDateTime(date: Date): string;
+export declare function formatDate(date: Date): string;
+export declare function grouped<A>(array: A[], n: number): A[][];
+export declare function objectToMap<T>(object: {
+    [key: string]: T;
+}): Map<string, T>;
+export declare function isEmpty(obj: object): boolean;
+export declare function addType<A, O extends object, I, T extends string>(codec: t.Type<A, O, I>, t: T): t.Type<A, O & {
+    __TYPE__: T;
+}, I>;

package/lib/validators/function.js

@@ -0,0 +1,60 @@
+"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]);
+}
+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);
+}
+exports.refineType = refineType;
+function filterDouble(value) {
+    if (value === "") {
+        return null;
+    }
+    const result = Number(value);
+    return Number.isNaN(result) ? null : result;
+}
+exports.filterDouble = filterDouble;
+function formatDateTime(date) {
+    return date.toISOString().replace(/\.\d{3}Z$/, "+0000");
+}
+exports.formatDateTime = formatDateTime;
+function formatDate(date) {
+    return date.toISOString().replace(/T.*/, "");
+}
+exports.formatDate = formatDate;
+function grouped(array, n) {
+    return array.reduce((acc, curr, idx) => {
+        if (idx % n === 0) {
+            acc.push([curr]);
+        }
+        else {
+            /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+            acc[Math.floor(idx / n)].push(curr);
+        }
+        return acc;
+    }, new Array());
+}
+exports.grouped = grouped;
+function objectToMap(object) {
+    return new Map(Object.entries(object));
+}
+exports.objectToMap = objectToMap;
+function isEmpty(obj) {
+    for (const _x in obj) {
+        return false;
+    }
+    return true;
+}
+exports.isEmpty = isEmpty;
+function addType(codec, t) {
+    return (0, mapOutput_1.mapOutput)(codec, (o) => ({ ...o, __TYPE__: t }));
+}
+exports.addType = addType;

package/lib/validators/index.d.ts

@@ -0,0 +1,12 @@
+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";

package/lib/validators/index.js

@@ -0,0 +1,27 @@
+"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.1.1",
+	"version": "0.2.3",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",
@@ -12,10 +12,10 @@
 	},
 	"license": "Apache-2.0",
 	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
-	"main": "dist/index.js",
-	"types": "dist/index.d.ts",
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
 	"files": [
-		"dist",
+		"lib",
 		"src"
 	],
 	"scripts": {
@@ -27,34 +27,46 @@
 		"release:dry": "standard-version --dry-run",
 		"release:alpha": "npm run test && standard-version --release-as major --prerelease alpha && git push --follow-tags && npm run build && npm publish --tag alpha",
 		"release:alpha:dry": "standard-version --release-as major --prerelease alpha --dry-run",
-		"lint": "eslint --ext .js,.ts .",
-		"unit": "nyc --reporter=lcovonly --reporter=text --exclude-after-remap=false ava",
-		"size": "size-limit",
-		"test": "npm run lint && npm run unit && npm run build && npm run size"
+		"test": "jest --no-cache --silent=false --verbose=false",
+		"eslint": "eslint . --cache --cache-location .caches/eslint --cache-strategy content --ext js,ts,tsx --max-warnings 0",
+		"eslint-fix": "npm run eslint -- --fix",
+		"preflight": "npm run prettier && npm run build && npm run eslint",
+		"prettier": "prettier --check .",
+		"prettier-write": "prettier --write ."
 	},
 	"dependencies": {
-		"fp-ts": "^2.11.8",
-		"io-ts": "^2.2.16",
-		"io-ts-types": "^0.5.16"
+		"monocle-ts": "^2.3.11",
+		"newtype-ts": "^0.3.5",
+		"tslib": "^2.3.1"
 	},
 	"devDependencies": {
-		"@size-limit/preset-small-lib": "^7.0.5",
+		"@relmify/jest-fp-ts": "^1.1.1",
+		"@types/jest": "^27.4.0",
 		"@typescript-eslint/eslint-plugin": "^5.8.1",
 		"@typescript-eslint/parser": "^5.8.1",
 		"ava": "^3.15.0",
-		"eslint": "^8.6.0",
-		"eslint-config-prettier": "^8.3.0",
-		"eslint-plugin-prettier": "^4.0.0",
-		"eslint-plugin-tsdoc": "^0.2.14",
+		"eslint": "8.6.0",
+		"eslint-config-prettier": "8.3.0",
+		"eslint-plugin-only-warn": "1.0.3",
+		"eslint-plugin-simple-import-sort": "7.0.0",
+		"eslint-plugin-storybook": "0.5.5",
+		"fp-ts": "^2.11.8",
+		"io-ts": "^2.2.16",
+		"io-ts-types": "^0.5.16",
+		"jest": "^27.5.1",
 		"nyc": "^15.1.0",
 		"prettier": "^2.5.1",
 		"prettier-plugin-jsdoc": "^0.3.30",
-		"siroc": "^0.16.0",
-		"size-limit": "^7.0.5",
 		"standard-version": "^9.3.2",
 		"ts-eager": "^2.0.2",
+		"ts-jest": "^27.1.3",
 		"typescript": "^4.5.5"
 	},
+	"peerDependencies": {
+		"fp-ts": "^2.11.8",
+		"io-ts": "^2.2.16",
+		"io-ts-types": "^0.5.16"
+	},
 	"engines": {
 		"node": ">=12.7.0"
 	},