@contentful/experience-delivery 1.0.0-dev.3

package/dist/esm/core/schemas/builders/date/date.mjs

@@ -0,0 +1,59 @@
+import { SchemaType } from "../../Schema.mjs";
+import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType.mjs";
+import { maybeSkipValidation } from "../../utils/maybeSkipValidation.mjs";
+import { getSchemaUtils } from "../schema-utils/index.mjs";
+// https://stackoverflow.com/questions/12756159/regex-and-iso8601-formatted-datetime
+const ISO_8601_REGEX = /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-2])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([T\s]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([.,]\d+(?!:))?)?(\17[0-5]\d([.,]\d+)?)?([zZ]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/;
+export function date() {
+    const baseSchema = {
+        parse: (raw, { breadcrumbsPrefix = [] } = {}) => {
+            if (typeof raw !== "string") {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: getErrorMessageForIncorrectType(raw, "string"),
+                        },
+                    ],
+                };
+            }
+            if (!ISO_8601_REGEX.test(raw)) {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: getErrorMessageForIncorrectType(raw, "ISO 8601 date string"),
+                        },
+                    ],
+                };
+            }
+            return {
+                ok: true,
+                value: new Date(raw),
+            };
+        },
+        json: (date, { breadcrumbsPrefix = [] } = {}) => {
+            if (date instanceof Date) {
+                return {
+                    ok: true,
+                    value: date.toISOString(),
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    errors: [
+                        {
+                            path: breadcrumbsPrefix,
+                            message: getErrorMessageForIncorrectType(date, "Date object"),
+                        },
+                    ],
+                };
+            }
+        },
+        getType: () => SchemaType.DATE,
+    };
+    return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
+}

package/dist/esm/core/schemas/builders/date/index.d.mts

@@ -0,0 +1 @@
+export { date } from "./date.mjs";

package/dist/esm/core/schemas/builders/date/index.mjs

@@ -0,0 +1 @@
+export { date } from "./date.mjs";

package/dist/esm/core/schemas/builders/enum/enum.d.mts

@@ -0,0 +1,3 @@
+import { type Schema } from "../../Schema.mjs";
+export declare function enum_<U extends string, E extends U[]>(values: E): Schema<E[number], E[number]>;
+export declare function forwardCompatibleEnum_<U extends string, E extends U[]>(values: E): Schema<E[number], string>;

package/dist/esm/core/schemas/builders/enum/enum.mjs

@@ -0,0 +1,41 @@
+import { SchemaType } from "../../Schema.mjs";
+import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator.mjs";
+import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType.mjs";
+export function enum_(values) {
+    const validValues = new Set(values);
+    const schemaCreator = createIdentitySchemaCreator(SchemaType.ENUM, (value, { allowUnrecognizedEnumValues, breadcrumbsPrefix = [] } = {}) => {
+        if (typeof value !== "string") {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: getErrorMessageForIncorrectType(value, "string"),
+                    },
+                ],
+            };
+        }
+        if (!validValues.has(value) && !allowUnrecognizedEnumValues) {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: getErrorMessageForIncorrectType(value, "enum"),
+                    },
+                ],
+            };
+        }
+        return {
+            ok: true,
+            value: value,
+        };
+    });
+    return schemaCreator();
+}
+export function forwardCompatibleEnum_(values) {
+    return enum_(values).transform({
+        transform: (val) => val,
+        untransform: (val) => val,
+    });
+}

package/dist/esm/core/schemas/builders/enum/index.d.mts

@@ -0,0 +1 @@
+export { enum_, forwardCompatibleEnum_ } from "./enum.mjs";

package/dist/esm/core/schemas/builders/enum/index.mjs

@@ -0,0 +1 @@
+export { enum_, forwardCompatibleEnum_ } from "./enum.mjs";

package/dist/esm/core/schemas/builders/index.d.mts

@@ -0,0 +1,14 @@
+export * from "./bigint/index.mjs";
+export * from "./date/index.mjs";
+export * from "./enum/index.mjs";
+export * from "./lazy/index.mjs";
+export * from "./list/index.mjs";
+export * from "./literals/index.mjs";
+export * from "./object/index.mjs";
+export * from "./object-like/index.mjs";
+export * from "./primitives/index.mjs";
+export * from "./record/index.mjs";
+export * from "./schema-utils/index.mjs";
+export * from "./set/index.mjs";
+export * from "./undiscriminated-union/index.mjs";
+export * from "./union/index.mjs";

package/dist/esm/core/schemas/builders/index.mjs

@@ -0,0 +1,14 @@
+export * from "./bigint/index.mjs";
+export * from "./date/index.mjs";
+export * from "./enum/index.mjs";
+export * from "./lazy/index.mjs";
+export * from "./list/index.mjs";
+export * from "./literals/index.mjs";
+export * from "./object/index.mjs";
+export * from "./object-like/index.mjs";
+export * from "./primitives/index.mjs";
+export * from "./record/index.mjs";
+export * from "./schema-utils/index.mjs";
+export * from "./set/index.mjs";
+export * from "./undiscriminated-union/index.mjs";
+export * from "./union/index.mjs";

package/dist/esm/core/schemas/builders/lazy/index.d.mts

@@ -0,0 +1,3 @@
+export type { SchemaGetter } from "./lazy.mjs";
+export { lazy } from "./lazy.mjs";
+export { lazyObject } from "./lazyObject.mjs";

package/dist/esm/core/schemas/builders/lazy/index.mjs

@@ -0,0 +1,2 @@
+export { lazy } from "./lazy.mjs";
+export { lazyObject } from "./lazyObject.mjs";

package/dist/esm/core/schemas/builders/lazy/lazy.d.mts

@@ -0,0 +1,5 @@
+import type { BaseSchema, Schema } from "../../Schema.mjs";
+export type SchemaGetter<SchemaType extends Schema<any, any>> = () => SchemaType;
+export declare function lazy<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): Schema<Raw, Parsed>;
+export declare function constructLazyBaseSchema<Raw, Parsed>(getter: SchemaGetter<Schema<Raw, Parsed>>): BaseSchema<Raw, Parsed>;
+export declare function getMemoizedSchema<SchemaType extends Schema<any, any>>(getter: SchemaGetter<SchemaType>): SchemaType;

package/dist/esm/core/schemas/builders/lazy/lazy.mjs

@@ -0,0 +1,19 @@
+import { getSchemaUtils } from "../schema-utils/index.mjs";
+export function lazy(getter) {
+    const baseSchema = constructLazyBaseSchema(getter);
+    return Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema));
+}
+export function constructLazyBaseSchema(getter) {
+    return {
+        parse: (raw, opts) => getMemoizedSchema(getter).parse(raw, opts),
+        json: (parsed, opts) => getMemoizedSchema(getter).json(parsed, opts),
+        getType: () => getMemoizedSchema(getter).getType(),
+    };
+}
+export function getMemoizedSchema(getter) {
+    const castedGetter = getter;
+    if (castedGetter.__zurg_memoized == null) {
+        castedGetter.__zurg_memoized = getter();
+    }
+    return castedGetter.__zurg_memoized;
+}

package/dist/esm/core/schemas/builders/lazy/lazyObject.d.mts

@@ -0,0 +1,3 @@
+import type { ObjectSchema } from "../object/types.mjs";
+import { type SchemaGetter } from "./lazy.mjs";
+export declare function lazyObject<Raw, Parsed>(getter: SchemaGetter<ObjectSchema<Raw, Parsed>>): ObjectSchema<Raw, Parsed>;

package/dist/esm/core/schemas/builders/lazy/lazyObject.mjs

@@ -0,0 +1,8 @@
+import { getObjectUtils } from "../object/index.mjs";
+import { getObjectLikeUtils } from "../object-like/index.mjs";
+import { getSchemaUtils } from "../schema-utils/index.mjs";
+import { constructLazyBaseSchema, getMemoizedSchema } from "./lazy.mjs";
+export function lazyObject(getter) {
+    const baseSchema = Object.assign(Object.assign({}, constructLazyBaseSchema(getter)), { _getRawProperties: () => getMemoizedSchema(getter)._getRawProperties(), _getParsedProperties: () => getMemoizedSchema(getter)._getParsedProperties() });
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, baseSchema), getSchemaUtils(baseSchema)), getObjectLikeUtils(baseSchema)), getObjectUtils(baseSchema));
+}

package/dist/esm/core/schemas/builders/list/index.d.mts

@@ -0,0 +1 @@
+export { list } from "./list.mjs";

package/dist/esm/core/schemas/builders/list/index.mjs

@@ -0,0 +1 @@
+export { list } from "./list.mjs";

package/dist/esm/core/schemas/builders/list/list.d.mts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.mjs";
+export declare function list<Raw, Parsed>(schema: Schema<Raw, Parsed>): Schema<Raw[], Parsed[]>;

package/dist/esm/core/schemas/builders/list/list.mjs

@@ -0,0 +1,46 @@
+import { SchemaType } from "../../Schema.mjs";
+import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType.mjs";
+import { maybeSkipValidation } from "../../utils/maybeSkipValidation.mjs";
+import { getSchemaUtils } from "../schema-utils/index.mjs";
+export function list(schema) {
+    const baseSchema = {
+        parse: (raw, opts) => validateAndTransformArray(raw, (item, index) => {
+            var _a;
+            return schema.parse(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
+        }),
+        json: (parsed, opts) => validateAndTransformArray(parsed, (item, index) => {
+            var _a;
+            return schema.json(item, Object.assign(Object.assign({}, opts), { breadcrumbsPrefix: [...((_a = opts === null || opts === void 0 ? void 0 : opts.breadcrumbsPrefix) !== null && _a !== void 0 ? _a : []), `[${index}]`] }));
+        }),
+        getType: () => SchemaType.LIST,
+    };
+    return Object.assign(Object.assign({}, maybeSkipValidation(baseSchema)), getSchemaUtils(baseSchema));
+}
+function validateAndTransformArray(value, transformItem) {
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            errors: [
+                {
+                    message: getErrorMessageForIncorrectType(value, "list"),
+                    path: [],
+                },
+            ],
+        };
+    }
+    const result = [];
+    const errors = [];
+    for (let i = 0; i < value.length; i++) {
+        const item = transformItem(value[i], i);
+        if (item.ok) {
+            result.push(item.value);
+        }
+        else {
+            errors.push(...item.errors);
+        }
+    }
+    if (errors.length === 0) {
+        return { ok: true, value: result };
+    }
+    return { ok: false, errors };
+}

package/dist/esm/core/schemas/builders/literals/booleanLiteral.d.mts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.mjs";
+export declare function booleanLiteral<V extends boolean>(literal: V): Schema<V, V>;

package/dist/esm/core/schemas/builders/literals/booleanLiteral.mjs

@@ -0,0 +1,25 @@
+import { SchemaType } from "../../Schema.mjs";
+import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator.mjs";
+import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType.mjs";
+export function booleanLiteral(literal) {
+    const schemaCreator = createIdentitySchemaCreator(SchemaType.BOOLEAN_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+        if (value === literal) {
+            return {
+                ok: true,
+                value: literal,
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: getErrorMessageForIncorrectType(value, `${literal.toString()}`),
+                    },
+                ],
+            };
+        }
+    });
+    return schemaCreator();
+}

package/dist/esm/core/schemas/builders/literals/index.d.mts

@@ -0,0 +1,2 @@
+export { booleanLiteral } from "./booleanLiteral.mjs";
+export { stringLiteral } from "./stringLiteral.mjs";

package/dist/esm/core/schemas/builders/literals/index.mjs

@@ -0,0 +1,2 @@
+export { booleanLiteral } from "./booleanLiteral.mjs";
+export { stringLiteral } from "./stringLiteral.mjs";

package/dist/esm/core/schemas/builders/literals/stringLiteral.d.mts

@@ -0,0 +1,2 @@
+import { type Schema } from "../../Schema.mjs";
+export declare function stringLiteral<V extends string>(literal: V): Schema<V, V>;

package/dist/esm/core/schemas/builders/literals/stringLiteral.mjs

@@ -0,0 +1,25 @@
+import { SchemaType } from "../../Schema.mjs";
+import { createIdentitySchemaCreator } from "../../utils/createIdentitySchemaCreator.mjs";
+import { getErrorMessageForIncorrectType } from "../../utils/getErrorMessageForIncorrectType.mjs";
+export function stringLiteral(literal) {
+    const schemaCreator = createIdentitySchemaCreator(SchemaType.STRING_LITERAL, (value, { breadcrumbsPrefix = [] } = {}) => {
+        if (value === literal) {
+            return {
+                ok: true,
+                value: literal,
+            };
+        }
+        else {
+            return {
+                ok: false,
+                errors: [
+                    {
+                        path: breadcrumbsPrefix,
+                        message: getErrorMessageForIncorrectType(value, `"${literal}"`),
+                    },
+                ],
+            };
+        }
+    });
+    return schemaCreator();
+}

package/dist/esm/core/schemas/builders/object/index.d.mts

@@ -0,0 +1,6 @@
+export { getObjectUtils, object } from "./object.mjs";
+export type { inferObjectWithoutOptionalPropertiesSchemaFromPropertySchemas, inferParsedObjectWithoutOptionalPropertiesFromPropertySchemas, } from "./objectWithoutOptionalProperties.mjs";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties.mjs";
+export type { Property } from "./property.mjs";
+export { isProperty, property } from "./property.mjs";
+export type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, inferParsedObject, inferParsedObjectFromPropertySchemas, inferParsedPropertySchema, inferRawKey, inferRawObject, inferRawObjectFromPropertySchemas, inferRawPropertySchema, ObjectSchema, ObjectUtils, PropertySchemas, } from "./types.mjs";

package/dist/esm/core/schemas/builders/object/index.mjs

@@ -0,0 +1,3 @@
+export { getObjectUtils, object } from "./object.mjs";
+export { objectWithoutOptionalProperties } from "./objectWithoutOptionalProperties.mjs";
+export { isProperty, property } from "./property.mjs";

package/dist/esm/core/schemas/builders/object/object.d.mts

@@ -0,0 +1,3 @@
+import type { BaseObjectSchema, inferObjectSchemaFromPropertySchemas, ObjectUtils, PropertySchemas } from "./types.mjs";
+export declare function object<ParsedKeys extends string, T extends PropertySchemas<ParsedKeys>>(schemas: T): inferObjectSchemaFromPropertySchemas<T>;
+export declare function getObjectUtils<Raw, Parsed>(schema: BaseObjectSchema<Raw, Parsed>): ObjectUtils<Raw, Parsed>;