@modulify/validator 0.0.2 → 0.2.0

package/dist/metadata.es.js

@@ -0,0 +1,131 @@
+const isValidator = (constraint) => "run" in constraint;
+function arrayify(value) {
+  return Array.isArray(value) ? [...value] : [value];
+}
+function matchesConstraints(value, constraints) {
+  return arrayify(constraints).every((constraint) => constraint.check(value));
+}
+const constraintDescriptorSymbol = /* @__PURE__ */ Symbol("modulify.validator.descriptor");
+const constraintMetadataSymbol = /* @__PURE__ */ Symbol("modulify.validator.metadata");
+const cloneCallableConstraint = (constraint) => {
+  const source = constraint;
+  const cloned = ((value) => source(value));
+  const {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    length: _length,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    name: _name,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    prototype: _prototype,
+    ...descriptors
+  } = Object.getOwnPropertyDescriptors(source);
+  Object.defineProperties(cloned, descriptors);
+  try {
+    Object.defineProperty(cloned, "name", {
+      configurable: true,
+      value: source.name
+    });
+  } catch {
+  }
+  Object.setPrototypeOf(cloned, Object.getPrototypeOf(source));
+  return cloned;
+};
+const cloneConstraint = (constraint) => {
+  if (typeof constraint === "function") {
+    return cloneCallableConstraint(constraint);
+  }
+  return Object.create(
+    Object.getPrototypeOf(constraint),
+    Object.getOwnPropertyDescriptors(constraint)
+  );
+};
+const freezeMetadata = (metadata) => Object.freeze({ ...metadata });
+const getConstraintMetadata = (constraint) => {
+  return constraint[constraintMetadataSymbol];
+};
+const getDescriptorFactory = (constraint) => {
+  return constraint[constraintDescriptorSymbol];
+};
+const getPublicDescriptor = (constraint) => {
+  if (!isValidator(constraint)) {
+    return void 0;
+  }
+  const { describe: describe2 } = constraint;
+  return typeof describe2 === "function" ? describe2.call(constraint) : void 0;
+};
+const inferAssertionDescriptor = (assertion) => ({
+  kind: "assertion",
+  name: assertion.name,
+  bail: assertion.bail,
+  code: assertion.name,
+  args: [],
+  constraints: assertion.constraints.map(([, , code, ...args]) => ({
+    code,
+    args
+  }))
+});
+const withMetadata = (descriptor, metadata) => {
+  if (!metadata) {
+    return descriptor;
+  }
+  return {
+    ...descriptor,
+    metadata
+  };
+};
+const attachConstraintDescriptor = (constraint, describe2) => {
+  Object.defineProperty(constraint, constraintDescriptorSymbol, {
+    configurable: false,
+    enumerable: false,
+    value: describe2,
+    writable: false
+  });
+  return constraint;
+};
+const meta = (constraint, metadata) => {
+  const cloned = cloneConstraint(constraint);
+  const nextMetadata = freezeMetadata({
+    ...getConstraintMetadata(constraint) ?? {},
+    ...metadata
+  });
+  Object.defineProperty(cloned, constraintMetadataSymbol, {
+    configurable: true,
+    enumerable: false,
+    value: nextMetadata,
+    writable: false
+  });
+  return cloned;
+};
+const custom = (validator) => validator;
+const describeConstraints = (constraints) => {
+  const values = arrayify(constraints);
+  return values.length === 1 ? describe(values[0]) : {
+    kind: "allOf",
+    constraints: values.map((value) => describe(value))
+  };
+};
+const describe = (constraint) => {
+  const factory = getDescriptorFactory(constraint);
+  const metadata = getConstraintMetadata(constraint);
+  if (factory) {
+    return withMetadata(factory(), metadata);
+  }
+  const publicDescriptor = getPublicDescriptor(constraint);
+  if (publicDescriptor) {
+    return withMetadata(publicDescriptor, metadata);
+  }
+  if (isValidator(constraint)) {
+    return withMetadata({ kind: "validator" }, metadata);
+  }
+  return withMetadata(inferAssertionDescriptor(constraint), metadata);
+};
+export {
+  arrayify as a,
+  describe as b,
+  custom as c,
+  describeConstraints as d,
+  attachConstraintDescriptor as e,
+  matchesConstraints as f,
+  isValidator as i,
+  meta as m
+};

package/dist/metadata.mjs

@@ -0,0 +1,8 @@
+import { e, c, b, d, m } from "./metadata.es.js";
+export {
+  e as attachConstraintDescriptor,
+  c as custom,
+  b as describe,
+  d as describeConstraints,
+  m as meta
+};

package/dist/predicates.cjs

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function hasProperty(key) {
+  return (value) => {
+    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+  };
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isEmail(value) {
+  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
+  return isString(value) && pattern.test(value);
+}
+function isExact(exact) {
+  return (value) => value === exact;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isNaN(value) {
+  return typeof value === "number" && Number.isNaN(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRecord(value) {
+  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+function constructorOf(value) {
+  return prototypeOf(value).constructor;
+}
+function prototypeOf(value) {
+  return Object.getPrototypeOf(value);
+}
+function And(...predicates) {
+  return (value) => {
+    return predicates.every((predicate) => predicate(value));
+  };
+}
+function Or(...predicates) {
+  return (value) => {
+    return predicates.some((predicate) => predicate(value));
+  };
+}
+function Not(predicate) {
+  return (value) => !predicate(value);
+}
+const isShape = (shape) => {
+  const properties = Object.keys(shape);
+  return (value) => isObject(value) && properties.every((p) => {
+    const config = shape[p];
+    const [predicate, required] = isArray(config) ? config : [config, true];
+    return p in value && value[p] !== void 0 && predicate(value[p]) || !required;
+  });
+};
+exports.And = And;
+exports.Not = Not;
+exports.Or = Or;
+exports.hasProperty = hasProperty;
+exports.isArray = isArray;
+exports.isBigInt = isBigInt;
+exports.isBlob = isBlob;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isEmail = isEmail;
+exports.isExact = isExact;
+exports.isFile = isFile;
+exports.isFunction = isFunction;
+exports.isMap = isMap;
+exports.isNaN = isNaN;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isObject = isObject;
+exports.isRecord = isRecord;
+exports.isSet = isSet;
+exports.isShape = isShape;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;

package/dist/predicates.d.ts

@@ -0,0 +1,56 @@
+import { Intersect, Predicate } from '../types';
+/** Checks if a value has a property */
+export declare function hasProperty<K extends PropertyKey = PropertyKey>(key: K): (value: unknown) => value is { [k in K]: unknown; };
+/** Checks if a value is an array */
+export declare function isArray(value: unknown): value is unknown[];
+/** Checks if a value is a boolean */
+export declare function isBoolean(value: unknown): value is boolean;
+/** Checks if a value is a bigint */
+export declare function isBigInt(value: unknown): value is bigint;
+/** Checks if a value is a Blob */
+export declare function isBlob(value: unknown): value is Blob;
+/** Checks if value is Date */
+export declare function isDate(value: unknown): value is Date;
+/** Checks if a value is an email */
+export declare function isEmail(value: unknown): value is string;
+/** Creates a predicate that checks if a value is equal to specified */
+export declare function isExact<T = unknown>(exact: T): (value: unknown) => value is T;
+/** Checks if a value is a File */
+export declare function isFile(value: unknown): value is File;
+/** Checks if a value is a function */
+export declare function isFunction<T extends (...args: never[]) => unknown = (...args: never[]) => unknown>(value: unknown): value is T;
+/** Checks if a value is a Map */
+export declare function isMap<K = unknown, V = unknown>(value: unknown): value is Map<K, V>;
+/** Checks if a value is NaN */
+export declare function isNaN(value: unknown): value is number;
+/** Checks if a value is null */
+export declare function isNull(value: unknown): value is null;
+/** Checks if a value is a number */
+export declare function isNumber(value: unknown): value is number;
+/** Checks if a value is an object, excluding null value */
+export declare function isObject(value: unknown): value is object;
+/** Check if a value is a record like Record<PropertyKey, unknown> */
+export declare function isRecord(value: unknown): value is Record<PropertyKey, unknown>;
+/** Checks if a value is a Set */
+export declare function isSet<T = unknown>(value: unknown): value is Set<T>;
+/** Checks if a value is a string */
+export declare function isString(value: unknown): value is string;
+/** Checks if a value is a symbol */
+export declare function isSymbol(value: unknown): value is symbol;
+/** Checks if a value is undefined */
+export declare function isUndefined(value: unknown): value is undefined;
+export declare function And<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<Intersect<T>>;
+export declare function Or<T extends unknown[]>(...predicates: [...{
+    [K in keyof T]: Predicate<T[K]>;
+}]): Predicate<T[number]>;
+export declare function Not<T>(predicate: Predicate<T>): Predicate;
+export type Shape<T extends object> = {
+    [K in keyof T]: [Predicate<T[K]>, boolean] | Predicate<T[K]>;
+};
+type ExtractType<T extends Shape<any>> = {
+    [K in keyof T]: T[K] extends [Predicate<infer U>, true] ? U : T[K] extends [Predicate<infer U>, false] ? U | undefined : never;
+} extends infer O ? O : never;
+export declare const isShape: <S extends Shape<any>>(shape: S) => (value: unknown) => value is ExtractType<S>;
+export {};

package/dist/predicates.mjs

@@ -0,0 +1,116 @@
+function hasProperty(key) {
+  return (value) => {
+    return isObject(value) && !isNull(value) && Object.prototype.hasOwnProperty.call(value, key);
+  };
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isEmail(value) {
+  const pattern = /^(([^<>()[\].,;:\s@"]+(\.[^<>()[\].,;:\s@"]+)*)|(".+"))@(([^<>()[\].,;:\s@"]+\.)+[^<>()[\].,;:\s@"]{2,})$/i;
+  return isString(value) && pattern.test(value);
+}
+function isExact(exact) {
+  return (value) => value === exact;
+}
+function isFile(value) {
+  return typeof File !== "undefined" && value instanceof File;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isNaN(value) {
+  return typeof value === "number" && Number.isNaN(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRecord(value) {
+  return isObject(value) && !isNull(value) && constructorOf(value) === Object && Object.keys(prototypeOf(value)).length === 0;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isUndefined(value) {
+  return typeof value === "undefined";
+}
+function constructorOf(value) {
+  return prototypeOf(value).constructor;
+}
+function prototypeOf(value) {
+  return Object.getPrototypeOf(value);
+}
+function And(...predicates) {
+  return (value) => {
+    return predicates.every((predicate) => predicate(value));
+  };
+}
+function Or(...predicates) {
+  return (value) => {
+    return predicates.some((predicate) => predicate(value));
+  };
+}
+function Not(predicate) {
+  return (value) => !predicate(value);
+}
+const isShape = (shape) => {
+  const properties = Object.keys(shape);
+  return (value) => isObject(value) && properties.every((p) => {
+    const config = shape[p];
+    const [predicate, required] = isArray(config) ? config : [config, true];
+    return p in value && value[p] !== void 0 && predicate(value[p]) || !required;
+  });
+};
+export {
+  And,
+  Not,
+  Or,
+  hasProperty,
+  isArray,
+  isBigInt,
+  isBlob,
+  isBoolean,
+  isDate,
+  isEmail,
+  isExact,
+  isFile,
+  isFunction,
+  isMap,
+  isNaN,
+  isNull,
+  isNumber,
+  isObject,
+  isRecord,
+  isSet,
+  isShape,
+  isString,
+  isSymbol,
+  isUndefined
+};

package/dist/violations.d.ts

@@ -0,0 +1,29 @@
+import { Violation } from '../types';
+type ViolationPath = readonly PropertyKey[];
+type ViolationTreeState<V extends Violation = Violation> = {
+    readonly path: ViolationPath;
+    readonly self: V[];
+    readonly subtree: V[];
+    readonly children: Map<PropertyKey, ViolationTreeState<V>>;
+};
+declare class TreeNode<V extends Violation = Violation> {
+    readonly path: readonly PropertyKey[];
+    readonly self: ViolationCollection<V>;
+    readonly subtree: ViolationCollection<V>;
+    readonly children: ReadonlyMap<PropertyKey, TreeNode<V>>;
+    constructor(state: ViolationTreeState<V>);
+    at(path: readonly PropertyKey[]): TreeNode<V> | undefined;
+}
+export declare class ViolationCollection<V extends Violation = Violation> implements Iterable<V> {
+    readonly size: number;
+    private readonly violations;
+    constructor(violations: readonly V[]);
+    [Symbol.iterator](): Iterator<V>;
+    forEach(callback: (violation: V, index: number, collection: ViolationCollection<V>) => void): void;
+    map<T>(callback: (violation: V, index: number, collection: ViolationCollection<V>) => T): T[];
+    at(path: readonly PropertyKey[]): ViolationCollection<V>;
+    tree(): TreeNode<V>;
+}
+export type ViolationTreeNode<V extends Violation = Violation> = TreeNode<V>;
+export declare const collection: <V extends Violation>(violations: readonly V[]) => ViolationCollection<V>;
+export {};

package/docker/services/node/Dockerfile

@@ -0,0 +1,9 @@
+FROM node:24
+
+WORKDIR /project
+
+RUN corepack enable && corepack prepare yarn@4.12.0 --activate \
+  && test "$(yarn --version)" = "4.12.0" \
+  && mkdir -p /home/node/.cache/node \
+  && cp -a /root/.cache/node/corepack /home/node/.cache/node/corepack \
+  && chown -R node:node /home/node/.cache

package/docs/en/00-index.md

@@ -0,0 +1,14 @@
+# Documentation
+
+- [Shape API](./01-shape-api.md) - Detailed guide to object shapes, derived helpers, unknown-key modes, and object-level rules.
+- [Metadata And Introspection](./02-metadata-and-introspection.md) - Detailed guide to `meta(...)`, `describe(...)`, shape descriptors, and custom validator descriptors.
+- [Violations](./03-violations.md) - Detailed guide to `Violation`, `ViolationCollection`, `collection(...)`, and tree/path semantics.
+- [JSON Schema Export](./04-json-schema-export.md) - Detailed guide to `toJsonSchema(...)`, supported mappings, metadata mapping, and strict vs best-effort export.
+- [Public API](./05-public-api.md) - Overview of root exports, subpath exports, validation result shape, and how the package surface is split.
+- [Common Recipes](./06-common-recipes.md) - Task-oriented recipes for choosing the right layer, validating payloads, reusing shapes, shaping UI errors, and exporting schemas safely.
+- [AI Reference](./07-ai-reference.md) - Compact contract summary for AI agents, tooling, and quick lookup of stable library semantics.
+- [Violation Code Types](./08-violation-code-types.md) - Detailed guide to `ViolationCodeRegistry`, `ViolationCode`, literal code preservation in descriptors, and external registry augmentation.
+
+## Translations
+
+- [Russian](../ru/00-index.md)