@temelyos/zod 1.0.0 → 1.0.1

package/dist/strip-to-schema.js

@@ -0,0 +1,35 @@
+import { unwrapField } from "./field-paths.js";
+import { isZodArray, isZodIntersection, isZodObject, isZodUnion } from "./utilities.js";
+import { isPlainObject } from "@temelyos/core/object";
+// src/strip-to-schema.ts
+function pick(schemas, value) {
+	const fields = schemas.flatMap(variantsOf);
+	if (Array.isArray(value)) {
+		const elements = fields.filter(isZodArray).map((field) => field.element);
+		return elements.length === 0 ? value : value.map((item) => pick(elements, item));
+	}
+	const shapes = fields.flatMap((field) => isZodObject(field) ? [field.shape] : []);
+	return shapes.length === 0 || !isPlainObject(value) ? value : pickFields(shapes, value);
+}
+/** The fields of `value` that any of `shapes` declares, each picked by every shape that declares it. */
+function pickFields(shapes, value) {
+	const record = value;
+	const picked = {};
+	for (const key of new Set(shapes.flatMap((shape) => Object.keys(shape)))) if (Object.hasOwn(record, key) && record[key] !== void 0) picked[key] = pick(shapes.flatMap((shape) => Object.hasOwn(shape, key) ? [shape[key]] : []), record[key]);
+	return picked;
+}
+/**
+* `value` cut down to the fields `schema` declares, at every depth: through arrays, optionals, nullables, defaults,
+* catches, lazies and the objects of a union or an intersection, merged. Nothing is parsed, so no checks, codecs or defaults run, and a
+* value that doesn't fit its field is copied as it is. `value` itself is picked by its keys, whatever its prototype.
+*/
+function stripToSchema(schema, value) {
+	return pickFields([schema.shape], value);
+}
+/** What `schema` holds a value as, through wrappers and lazies: each option of a union, each side of an intersection, or itself. */
+function variantsOf(schema) {
+	const field = unwrapField(schema, true);
+	if (isZodIntersection(field)) return [...variantsOf(field.def.left), ...variantsOf(field.def.right)];
+	return isZodUnion(field) ? field.options.flatMap(variantsOf) : [field];
+}
+export { stripToSchema };

package/dist/time-zone.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+/**
+ * A field that takes an IANA zone this runtime can actually format in.
+ *
+ * The check belongs at the write boundary: an unsupported zone is stored happily and then
+ * throws a `RangeError` inside `Intl` on every later read, far from whatever put it there.
+ *
+ * The message is the CALLER's, as `objectId`'s is, for two reasons. A domain says what it
+ * wants in its own words — "Select a valid time zone." on a form, "Invalid time zone." on a
+ * public booking — and the i18n extractor harvests a plain zod message where it is written,
+ * so a sentence buried in here would reach no dictionary. `whenEmpty` is separate for a form
+ * that distinguishes a field nobody filled in from one filled in wrongly; left out, one
+ * message answers for both.
+ */
+export declare function timeZone(message: string, whenEmpty?: string): z.ZodString;

package/dist/time-zone.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { isSupportedTimezone } from "@temelyos/core/time-zone";
+// src/time-zone.ts
+/**
+* A field that takes an IANA zone this runtime can actually format in.
+*
+* The check belongs at the write boundary: an unsupported zone is stored happily and then
+* throws a `RangeError` inside `Intl` on every later read, far from whatever put it there.
+*
+* The message is the CALLER's, as `objectId`'s is, for two reasons. A domain says what it
+* wants in its own words — "Select a valid time zone." on a form, "Invalid time zone." on a
+* public booking — and the i18n extractor harvests a plain zod message where it is written,
+* so a sentence buried in here would reach no dictionary. `whenEmpty` is separate for a form
+* that distinguishes a field nobody filled in from one filled in wrongly; left out, one
+* message answers for both.
+*/
+function timeZone(message, whenEmpty = message) {
+	return z.string().min(1, whenEmpty).refine(isSupportedTimezone, message);
+}
+export { timeZone };

package/dist/to-json-schema.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+/**
+ * A JSON Schema document, as {@link toJsonSchema} produces.
+ *
+ * An object rather than `unknown` because these schemas exist to be READ: an editor
+ * walks `properties` to build its field pickers. As `unknown`, every consumer casts
+ * before it can index - at exactly the boundary that was supposed to describe the value.
+ *
+ * Deliberately not modelled more precisely than "a JSON object". JSON Schema is
+ * recursive and open-ended, and restating its grammar here would be a second, worse
+ * copy of a specification we do not own.
+ */
+export declare const JsonSchemaDocument: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export type JsonSchemaDocument = z.infer<typeof JsonSchemaDocument>;
+export interface ToJsonSchemaOptions {
+  /** Describe what the schema accepts (`input`) or what it produces (`output`, the default). */
+  io?: 'input' | 'output';
+  /**
+   * What to do with a type JSON Schema cannot describe (bigint, Map, a transform...).
+   * `throw`, the default, fails the conversion; `any` describes it as `{}`, for a
+   * consumer that would rather offer a loose schema than none.
+   */
+  unrepresentable?: 'any' | 'throw';
+}
+/**
+ * `z.toJSONSchema`, with dates described rather than refused.
+ *
+ * zod has no JSON Schema for `z.date()` and throws on it by default, so one date field
+ * anywhere in a schema fails the whole conversion - which is how one event with a
+ * `startAt` blanked the workflow editor, and why every domain model's schema endpoint
+ * answered 500. Here a date is `{ type: 'string', format: 'date-time' }`, the node
+ * `z.iso.datetime()` produces, so a reader sees the same field either way, and an
+ * `isoDate()` reads the same as `z.date()` on either side; an `isoDay()` is a `format: 'date'`
+ * string on either side. The value
+ * itself is untouched: a schema that takes a `Date` still takes a `Date`.
+ *
+ * Use this rather than `z.toJSONSchema`; the lint rule `no-restricted-properties`
+ * points there.
+ */
+export declare function toJsonSchema(schema: z.ZodType, options?: ToJsonSchemaOptions): JsonSchemaDocument;

package/dist/to-json-schema.js

@@ -0,0 +1,44 @@
+import { dateFormat } from "./iso-date.js";
+import { z } from "zod";
+// src/to-json-schema.ts
+/**
+* A JSON Schema document, as {@link toJsonSchema} produces.
+*
+* An object rather than `unknown` because these schemas exist to be READ: an editor
+* walks `properties` to build its field pickers. As `unknown`, every consumer casts
+* before it can index - at exactly the boundary that was supposed to describe the value.
+*
+* Deliberately not modelled more precisely than "a JSON object". JSON Schema is
+* recursive and open-ended, and restating its grammar here would be a second, worse
+* copy of a specification we do not own.
+*/
+const JsonSchemaDocument = z.record(z.string(), z.unknown());
+/**
+* `z.toJSONSchema`, with dates described rather than refused.
+*
+* zod has no JSON Schema for `z.date()` and throws on it by default, so one date field
+* anywhere in a schema fails the whole conversion - which is how one event with a
+* `startAt` blanked the workflow editor, and why every domain model's schema endpoint
+* answered 500. Here a date is `{ type: 'string', format: 'date-time' }`, the node
+* `z.iso.datetime()` produces, so a reader sees the same field either way, and an
+* `isoDate()` reads the same as `z.date()` on either side; an `isoDay()` is a `format: 'date'`
+* string on either side. The value
+* itself is untouched: a schema that takes a `Date` still takes a `Date`.
+*
+* Use this rather than `z.toJSONSchema`; the lint rule `no-restricted-properties`
+* points there.
+*/
+function toJsonSchema(schema, options = {}) {
+	const otherwise = options.unrepresentable ?? "throw";
+	return z.toJSONSchema(schema, {
+		io: options.io,
+		unrepresentable: ({ zodSchema }) => {
+			const format = dateFormat(zodSchema) ?? (zodSchema._zod.def.type === "date" ? "date-time" : void 0);
+			return format ? {
+				format,
+				type: "string"
+			} : otherwise;
+		}
+	});
+}
+export { JsonSchemaDocument, toJsonSchema };

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNonOptional, ZodNullable, ZodOptional, ZodPromise, ZodSuccess } from "zod";
+export type Mutable<T> = { -readonly [P in keyof T]: T[P]; };
+export type UnwrapZodType<T> = T extends ZodOptional<infer U> ? UnwrapZodType<U> : T extends ZodNullable<infer U> ? UnwrapZodType<U> : T extends ZodDefault<infer U> ? UnwrapZodType<U> : T extends ZodCatch<infer U> ? UnwrapZodType<U> : T extends ZodLazy<infer U> ? UnwrapZodType<U> : T extends ZodArray<infer U> ? ZodArray<UnwrapZodType<U>> : T;
+export type ZodWrapper = ZodCatch | ZodDefault | ZodLazy | ZodNonOptional | ZodNullable | ZodOptional | ZodPromise | ZodSuccess;

package/dist/utilities.d.ts

@@ -0,0 +1,39 @@
+import { ZodWrapper } from "./types.js";
+import { ZodArray, ZodCatch, ZodCodec, ZodDate, ZodDefault, ZodEnum, ZodIntersection, ZodLazy, ZodNullable, ZodNumber, ZodObject, ZodOptional, ZodPipe, ZodRecord, ZodString, ZodTransform, ZodType, ZodUnion, ZodUnknown } from "zod";
+export declare const ZOD_WRAPPER_TYPES: string[];
+export declare function getInnerType(schema: ZodType): ZodType;
+export declare function isFieldNullable(schema: ZodType): boolean;
+/**
+ * Whether `schema` is declared `.optional()`, looking only through `.optional()` and `.nullable()`: what a form or a
+ * write may leave empty. For whether a parsed value may lack the field, through any wrapper, use {@link isOptionalOutput}.
+ */
+export declare function isFieldOptional(schema: ZodType): boolean;
+/**
+ * Whether a value typed by what `schema` outputs may lack the field: optional through any wrapper (lazy, readonly, a
+ * union with an optional member), as zod decides it, not filled by a default; and `any` or `unknown`, whose type takes
+ * `undefined` already. What a read typed by the schema may lack; for a field declared `.optional()`, {@link isFieldOptional}.
+ */
+export declare function isOptionalOutput(schema: ZodType): boolean;
+export declare function isZodAny(obj: unknown): obj is ZodType;
+export declare function isZodArray(obj: unknown): obj is ZodArray<ZodType>;
+export declare function isZodCatch<T extends ZodType>(obj: unknown): obj is ZodCatch<T>;
+/** A codec, as `z.codec` builds: a pipe that can also run backwards. Read it as its `out`, what it decodes to. */
+export declare function isZodCodec(obj: unknown): obj is ZodCodec;
+export declare function isZodDate(obj: unknown): obj is ZodDate;
+export declare function isZodDefault(obj: unknown): obj is ZodDefault;
+export declare function isZodEnum(obj: unknown): obj is ZodEnum;
+export declare function isZodIntersection(obj: unknown): obj is ZodIntersection<ZodType, ZodType>;
+export declare function isZodLazy(obj: unknown): obj is ZodLazy;
+export declare function isZodNullable(obj: unknown): obj is ZodNullable<ZodType>;
+export declare function isZodNumber(obj: unknown): obj is ZodNumber;
+export declare function isZodObject(obj: unknown, isLoose?: boolean): obj is ZodObject;
+export declare function isZodObjectLoose(obj: ZodObject): boolean;
+export declare function isZodOptional(obj: unknown): obj is ZodOptional<ZodType>;
+export declare function isZodPipe(obj: unknown): obj is ZodPipe;
+export declare function isZodRecord(obj: unknown): obj is ZodRecord;
+export declare function isZodString(obj: unknown): obj is ZodString;
+export declare function isZodTransform(obj: unknown): obj is ZodTransform;
+export declare function isZodType(obj: unknown): obj is ZodType;
+export declare function isZodUnion(obj: unknown): obj is ZodUnion<ZodType[]>;
+export declare function isZodUnknown(obj: unknown): obj is ZodUnknown;
+export declare function isZodWrapper(obj: unknown): obj is ZodWrapper;

package/dist/utilities.js

@@ -0,0 +1,116 @@
+import { ZodArray, ZodCatch, ZodDefault, ZodLazy, ZodNullable, ZodOptional } from "zod";
+// src/utilities.ts
+const ZOD_WRAPPER_TYPES = [
+	"catch",
+	"default",
+	"lazy",
+	"nonoptional",
+	"nullable",
+	"optional",
+	"promise",
+	"success"
+];
+function getInnerType(schema) {
+	if (schema instanceof ZodOptional || schema instanceof ZodNullable || schema instanceof ZodDefault || schema instanceof ZodCatch) return getInnerType(schema.def.innerType);
+	if (schema instanceof ZodLazy) return getInnerType(schema.def.getter());
+	if (schema instanceof ZodArray) return getInnerType(schema.def.element);
+	return schema;
+}
+function isFieldNullable(schema) {
+	let current = schema;
+	while (isZodOptional(current) || isZodNullable(current)) {
+		if (isZodNullable(current)) return true;
+		current = current.def.innerType;
+	}
+	return false;
+}
+/**
+* Whether `schema` is declared `.optional()`, looking only through `.optional()` and `.nullable()`: what a form or a
+* write may leave empty. For whether a parsed value may lack the field, through any wrapper, use {@link isOptionalOutput}.
+*/
+function isFieldOptional(schema) {
+	let current = schema;
+	while (isZodOptional(current) || isZodNullable(current)) {
+		if (isZodOptional(current)) return true;
+		current = current.def.innerType;
+	}
+	return false;
+}
+/**
+* Whether a value typed by what `schema` outputs may lack the field: optional through any wrapper (lazy, readonly, a
+* union with an optional member), as zod decides it, not filled by a default; and `any` or `unknown`, whose type takes
+* `undefined` already. What a read typed by the schema may lack; for a field declared `.optional()`, {@link isFieldOptional}.
+*/
+function isOptionalOutput(schema) {
+	return schema._zod.optout === "optional" || schema.def.type === "any" || schema.def.type === "unknown";
+}
+function isZodAny(obj) {
+	return isZodType(obj) && obj.def.type === "any";
+}
+function isZodArray(obj) {
+	return isZodType(obj) && obj.def.type === "array";
+}
+function isZodCatch(obj) {
+	return isZodType(obj) && obj.def.type === "catch";
+}
+/** A codec, as `z.codec` builds: a pipe that can also run backwards. Read it as its `out`, what it decodes to. */
+function isZodCodec(obj) {
+	return isZodPipe(obj) && "reverseTransform" in obj.def;
+}
+function isZodDate(obj) {
+	return isZodType(obj) && obj.def.type === "date";
+}
+function isZodDefault(obj) {
+	return isZodType(obj) && obj.def.type === "default";
+}
+function isZodEnum(obj) {
+	return isZodType(obj) && obj.def.type === "enum";
+}
+function isZodIntersection(obj) {
+	return isZodType(obj) && obj.def.type === "intersection";
+}
+function isZodLazy(obj) {
+	return isZodType(obj) && obj.def.type === "lazy";
+}
+function isZodNullable(obj) {
+	return isZodType(obj) && obj.def.type === "nullable";
+}
+function isZodNumber(obj) {
+	return isZodType(obj) && obj.def.type === "number";
+}
+function isZodObject(obj, isLoose) {
+	if (!isZodType(obj) || obj.def.type !== "object") return false;
+	if (typeof isLoose === "undefined") return true;
+	return isLoose === isZodObjectLoose(obj);
+}
+function isZodObjectLoose(obj) {
+	return !!isZodUnknown(obj.def.catchall);
+}
+function isZodOptional(obj) {
+	return isZodType(obj) && obj.def.type === "optional";
+}
+function isZodPipe(obj) {
+	return isZodType(obj) && obj.def.type === "pipe";
+}
+function isZodRecord(obj) {
+	return isZodType(obj) && obj.def.type === "record";
+}
+function isZodString(obj) {
+	return isZodType(obj) && obj.def.type === "string";
+}
+function isZodTransform(obj) {
+	return isZodType(obj) && obj.def.type === "transform";
+}
+function isZodType(obj) {
+	return typeof obj === "object" && obj !== null && "def" in obj && "safeParse" in obj && typeof obj.safeParse === "function";
+}
+function isZodUnion(obj) {
+	return isZodType(obj) && obj.def.type === "union";
+}
+function isZodUnknown(obj) {
+	return isZodType(obj) && obj.def.type === "unknown";
+}
+function isZodWrapper(obj) {
+	return isZodType(obj) && ZOD_WRAPPER_TYPES.includes(obj.def.type);
+}
+export { ZOD_WRAPPER_TYPES, getInnerType, isFieldNullable, isFieldOptional, isOptionalOutput, isZodAny, isZodArray, isZodCatch, isZodCodec, isZodDate, isZodDefault, isZodEnum, isZodIntersection, isZodLazy, isZodNullable, isZodNumber, isZodObject, isZodObjectLoose, isZodOptional, isZodPipe, isZodRecord, isZodString, isZodTransform, isZodType, isZodUnion, isZodUnknown, isZodWrapper };

package/dist/whole-number.d.ts

@@ -0,0 +1,2 @@
+export declare const NonNegativeInteger: import("zod").ZodNumber;
+export declare const PositiveInteger: import("zod").ZodNumber;

package/dist/whole-number.js

@@ -0,0 +1,11 @@
+import { boundedNumber } from "./bounded-number.js";
+// src/whole-number.ts
+const NonNegativeInteger = boundedNumber({
+	integer: true,
+	min: 0
+});
+const PositiveInteger = boundedNumber({
+	integer: true,
+	min: 1
+});
+export { NonNegativeInteger, PositiveInteger };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temelyos/zod",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Zod schemas and helpers for Temelyos: ids, ISO dates and days, localized strings, field settings, JSON Schema conversion, and schema merging and stripping.",
   "author": "Secure Data Systems",
   "license": "ISC",
@@ -30,11 +30,14 @@
     }
   },
   "dependencies": {
-    "zod": "^4.6.7",
     "@temelyos/core": "^1.0.1"
   },
+  "peerDependencies": {
+    "zod": "^4.6.7"
+  },
   "devDependencies": {
     "tsdown": "^0.23.3",
+    "zod": "^4.6.7",
     "@temelyos/tsdown-config": "^0.0.0",
     "@temelyos/typescript-config": "^0.0.0"
   },