@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

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/TrimmedString.d.ts

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare type TrimmedStringC = 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/TrimmedString.js

@@ -0,0 +1,23 @@
+"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"));
+function trimScalaStyle(s) {
+    let startAt = 0;
+    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+    while (startAt < s.length && s[startAt] <= " ") {
+        startAt++;
+    }
+    let endAt = s.length;
+    /* eslint-disable  @typescript-eslint/no-non-null-assertion */
+    while (startAt < endAt && s[endAt - 1] <= " ") {
+        endAt--;
+    }
+    return s.substring(startAt, endAt);
+}
+/** A codec that validates a Boolean and convert it as a string */
+exports.default = new t.Type("TrimmedString", t.string.is, (u, c) => (0, function_1.pipe)(t.string.validate(u, c), (0, Either_1.chain)((s) => {
+    return t.success(trimScalaStyle(s));
+})), (i) => i);

package/lib/validators/function.d.ts

@@ -0,0 +1,34 @@
+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>;
+/**
+ * Returns a clone of the given codec that tries to find sub-error with message already set.
+ * If there is such error it just returns sub-errors array.
+ * If there is no such error it generates new error with given message.
+ *
+ * @example
+ * expect(
+ * 		withCustomError(
+ * 			t.type({age: withCustomError(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withCustomError(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+export declare function withCustomError<C extends t.Any>(codec: C, message: (i: t.InputOf<C>, c: t.Context) => string): C;

package/lib/validators/function.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCustomError = 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 io_ts_types_1 = require("io-ts-types");
+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;
+/**
+ * Returns a clone of the given codec that tries to find sub-error with message already set.
+ * If there is such error it just returns sub-errors array.
+ * If there is no such error it generates new error with given message.
+ *
+ * @example
+ * expect(
+ * 		withCustomError(
+ * 			t.type({age: withCustomError(t.number, () => 'Invalid child')}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid child"}])
+ * expect(
+ * 		withCustomError(
+ * 			t.type({age: t.number}),
+ * 			() => "Invalid parent"
+ * 		)
+ * ).toSubsetEqualLeft([{message: "Invalid parent"}])
+ */
+function withCustomError(codec, message) {
+    return (0, io_ts_types_1.withValidate)(codec, (i, c) => {
+        return fp_ts_1.either.mapLeft((errors) => {
+            if (errors.find((error) => error.message)) {
+                return errors;
+            }
+            return [
+                {
+                    value: i,
+                    context: c,
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                    message: message(i, c),
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                    actual: i,
+                },
+            ];
+        })(codec.validate(i, c));
+    });
+}
+exports.withCustomError = withCustomError;

package/lib/validators/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./BasicTypes";
+export { default as DateFromString } from "./DateFromString";
+export { default as DateFromStringOrNumber } from "./DateFromStringOrNumber";
+export { default as DateFromTsMs } from "./DateFromTsMs";
+export * from "./DefaultOrElse";
+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 NumberRange } from "./NumberRange";
+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,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringOrNull = exports.StringFromNumber = exports.StringFromBoolean = exports.NumberRange = 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");
+(0, tslib_1.__exportStar)(require("./BasicTypes"), exports);
+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; } });
+(0, tslib_1.__exportStar)(require("./DefaultOrElse"), exports);
+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 NumberRange_1 = require("./NumberRange");
+Object.defineProperty(exports, "NumberRange", { enumerable: true, get: function () { return (0, tslib_1.__importDefault)(NumberRange_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,97 +1,77 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.17.0-pr.145.680cd65",
-	"description": "Prismic internal types for content and models",
+	"version": "3.17.2",
+	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
-		"prismic",
-		"typescript"
+		"typescript",
+		"prismic"
 	],
-	"license": "Apache-2.0",
-	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
 	"repository": {
 		"type": "git",
 		"url": "ssh://git@github.com/prismicio/prismic-types-internal.git"
 	},
+	"license": "Apache-2.0",
+	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
+	"main": "lib/index.js",
+	"types": "lib/index.d.ts",
 	"files": [
-		"./dist",
-		"./src"
+		"lib",
+		"src"
 	],
-	"type": "module",
-	"typesVersions": {
-		"*": {
-			"lib/*": [
-				"./dist/*/index.d.ts",
-				"./dist/*.d.ts"
-			]
-		}
-	},
-	"exports": {
-		"./lib/common": {
-			"import": "./dist/common/index.js",
-			"require": "./dist/common/index.cjs"
-		},
-		"./lib/content": {
-			"import": "./dist/content/index.js",
-			"require": "./dist/content/index.cjs"
-		},
-		"./lib/customtypes": {
-			"import": "./dist/customtypes/index.js",
-			"require": "./dist/customtypes/index.cjs"
-		},
-		"./lib/utils": {
-			"import": "./dist/utils/index.js",
-			"require": "./dist/utils/index.cjs"
-		},
-		"./lib/validators": {
-			"import": "./dist/validators/index.js",
-			"require": "./dist/validators/index.cjs"
-		},
-		"./lib/*.js": {
-			"import": "./dist/*.js",
-			"require": "./dist/*.cjs"
-		},
-		"./lib/*": {
-			"import": "./dist/*.js",
-			"require": "./dist/*.cjs"
-		},
-		"./package.json": "./package.json"
-	},
-	"publishConfig": {
-		"access": "public"
-	},
 	"scripts": {
-		"build": "tsdown",
-		"dev": "tsdown --watch",
-		"format": "oxfmt",
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"format": "prettier --write .",
 		"prepare": "npm run build",
-		"lint": "oxlint --deny-warnings",
-		"types": "tsc --noEmit",
-		"unit": "vitest run --coverage",
-		"unit:watch": "vitest watch",
-		"test": "npm run lint && npm run types && npm run unit && npm run build"
+		"test": "jest --no-cache --silent=false --verbose=false --coverage",
+		"test:watch": "npm run test -- --watch",
+		"test:clear": "jest --clearCache",
+		"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 && npm run test",
+		"prettier": "prettier --check .",
+		"prettier-write": "prettier --write ."
 	},
 	"dependencies": {
-		"monocle-ts": "^2.3.13",
-		"newtype-ts": "^0.3.5"
+		"monocle-ts": "^2.3.11",
+		"newtype-ts": "^0.3.5",
+		"tslib": "^2.3.1",
+		"uuid": "^11.1.1"
 	},
 	"devDependencies": {
-		"@types/node": "^25.2.3",
-		"@vitest/coverage-v8": "^4.0.18",
-		"fp-ts": "^2.16.11",
-		"io-ts": "^2.2.22",
-		"io-ts-types": "^0.5.19",
-		"oxfmt": "^0.33.0",
-		"oxlint": "^1.48.0",
-		"tsdown": "^0.20.3",
-		"typescript": "^5.9.3",
-		"vitest": "^4.0.18"
+		"@fast-check/jest": "^1.4.0",
+		"@relmify/jest-fp-ts": "^1.1.1",
+		"@types/jest": "^27.4.0",
+		"@types/uuid": "^10.0.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-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.7.1",
+		"prettier-plugin-jsdoc": "^0.3.30",
+		"standard-version": "^9.3.2",
+		"ts-eager": "^2.0.2",
+		"ts-jest": "^27.1.3",
+		"typescript": "^4.5.5"
 	},
 	"peerDependencies": {
-		"fp-ts": "^2.16.11",
-		"io-ts": "^2.2.22",
-		"io-ts-types": "^0.5.19"
+		"fp-ts": "^2.11.8",
+		"io-ts": "^2.2.16",
+		"io-ts-types": "^0.5.16"
 	},
 	"engines": {
-		"node": ">=20"
+		"node": ">=16"
+	},
+	"publishConfig": {
+		"access": "public"
 	}
 }

package/src/common/Asset.ts

@@ -15,7 +15,8 @@ export type Asset = {
 }
 
 export const getAssetOrThrow =
-	(assets: Record<Asset["id"], Asset | undefined>) => (assetId: Asset["id"]) => {
+	(assets: Record<Asset["id"], Asset | undefined>) =>
+	(assetId: Asset["id"]) => {
 		const asset = assets[assetId]
 		if (!asset) {
 			throw new Error(`Missing asset with id '${assetId}'!`)

package/src/common/HexaColorCode.ts

@@ -6,5 +6,6 @@ export type HexaColorCode = `#${string}`
 
 const hexaColorCodeRegex = /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/
 export const HexaColor = {
-	is: (strColor: string): strColor is HexaColorCode => hexaColorCodeRegex.test(strColor),
+	is: (strColor: string): strColor is HexaColorCode =>
+		hexaColorCodeRegex.test(strColor),
 }

package/src/common/UUID.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts"
+import { validate as validateUUID } from "uuid"
 
 import { withCustomError } from "../validators/function"
 
@@ -9,11 +10,7 @@ export interface UUIDBrand {
 export const UUID = withCustomError(
 	t.brand(
 		t.string,
-		(s): s is t.Branded<string, UUIDBrand> =>
-			typeof s === "string" &&
-			/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i.test(
-				s,
-			),
+		(s): s is t.Branded<string, UUIDBrand> => validateUUID(s),
 		"UUID",
 	),
 	() => "The value must be a valid UUID",