@valbuild/core 0.79.4 → 0.80.0

package/dist/declarations/src/index.d.ts

@@ -20,11 +20,11 @@ export { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG } from "./source/file.js";
 export { VAL_EXTENSION, type SourceArray } from "./source/index.js";
 export { derefPatch } from "./patch/deref.js";
 export { type SelectorSource, type SelectorOf, GenericSelector, } from "./selector/index.js";
-import { getSource, splitModulePath, splitModuleFilePath, resolvePath, safeResolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths } from "./module.js";
+import { getSource, splitModulePath, splitModuleFilePath, resolvePath, safeResolvePath, splitModuleFilePathAndModulePath, joinModuleFilePathAndModulePath, parentOfSourcePath, patchPathToModulePath, splitJoinedSourcePaths, type ValModule } from "./module.js";
 declare const ModuleFilePathSep = "?p=";
 export { ModuleFilePathSep };
-import { getSchema } from "./selector/index.js";
-import { ModulePath, getValPath, isVal } from "./val/index.js";
+import { SelectorSource, getSchema } from "./selector/index.js";
+import { ModulePath, SourcePath, getValPath, isVal } from "./val/index.js";
 import { convertFileSource } from "./schema/file.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
 import { Operation } from "./patch/index.js";
@@ -78,6 +78,7 @@ declare const Internal: {
         hashToRemoteFileHash: typeof hashToRemoteFileHash;
         splitRemoteRef: typeof splitRemoteRef;
     };
+    validate: (val: ValModule<SelectorSource>, path: SourcePath, src: unknown) => import("./schema/validation/ValidationError.js").ValidationErrors | undefined;
     isVal: typeof isVal;
     isFile: typeof isFile;
     createValPathOfItem: typeof createValPathOfItem;

package/dist/declarations/src/initSchema.d.ts

@@ -46,7 +46,7 @@ export type InitSchema = {
 };
 export declare function initSchema(): {
     string: <T extends string>(options?: Record<string, never> | undefined) => import("./schema/string.js").StringSchema<T>;
-    boolean: () => import("./schema/index.js").Schema<boolean>;
+    boolean: () => import("./schema/boolean.js").BooleanSchema<boolean>;
     array: <S extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S) => import("./schema/array.js").ArraySchema<S, import("./schema/index.js").SelectorOfSchema<S>[]>;
     object: <Props extends {
         [key: string]: import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>;
@@ -58,7 +58,7 @@ export declare function initSchema(): {
         andThen?: undefined;
         assert?: undefined;
         fold?: undefined;
-    }>(schema: Props) => import("./schema/index.js").Schema<{ [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
+    }>(schema: Props) => import("./schema/object.js").ObjectSchema<Props, { [key in keyof Props]: import("./schema/index.js").SelectorOfSchema<Props[key]>; }>;
     number: (options?: {
         max?: number | undefined;
         min?: number | undefined;
@@ -73,7 +73,7 @@ export declare function initSchema(): {
         _type?: undefined;
         val?: undefined;
         valPath?: undefined;
-    } & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T_1) => import("./schema/index.js").Schema<T_1 extends import("./schema/index.js").Schema<infer S_1 extends import("./selector/index.js").SelectorSource>[] ? S_1 extends import("./selector/index.js").SelectorSource ? S_1 | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
+    } & { [k in Key]: string; } : Key extends import("./schema/index.js").Schema<string> ? string : unknown>[]>(key: Key, ...objects: T_1) => import("./schema/union.js").UnionSchema<Key, T_1, T_1 extends import("./schema/index.js").Schema<infer S_1 extends import("./selector/index.js").SelectorSource>[] ? S_1 extends import("./selector/index.js").SelectorSource ? S_1 | (Key extends import("./schema/index.js").Schema<infer K extends import("./selector/index.js").SelectorSource> ? K : never) : never : never>;
     richtext: <O extends Partial<{
         style: Partial<{
             bold: boolean;
@@ -97,7 +97,7 @@ export declare function initSchema(): {
     }>>(options?: O | undefined) => import("./schema/richtext.js").RichTextSchema<O, import("./index.js").RichTextSource<O>>;
     image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/image.js").ImageSchema<import("./index.js").ImageSource>;
     literal: <T_2 extends string>(value: T_2) => import("./schema/literal.js").LiteralSchema<T_2>;
-    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly import("./source/index.js").Source[] ? number : S_2 extends import("./source/index.js").SourceObject ? string extends keyof S_2 ? import("./schema/string.js").RawString : keyof S_2 : S_2 extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
+    keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/keyOf.js").KeyOfSchema<Src, Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly import("./source/index.js").Source[] ? number : S_2 extends import("./source/index.js").SourceObject ? string extends keyof S_2 ? import("./schema/string.js").RawString : keyof S_2 : S_2 extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
     record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/record.js").RecordSchema<S_3, Record<string, import("./schema/index.js").SelectorOfSchema<S_3>>>;
     file: (options?: import("./schema/file.js").FileOptions | undefined) => import("./schema/file.js").FileSchema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
     date: (options?: Record<string, never> | undefined) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;

package/dist/declarations/src/schema/array.d.ts

@@ -8,15 +8,18 @@ export type SerializedArraySchema = {
     type: "array";
     item: SerializedSchema;
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class ArraySchema<T extends Schema<SelectorSource>, Src extends SelectorOfSchema<T>[] | null> extends Schema<Src> {
-    readonly item: T;
-    readonly opt: boolean;
-    constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedArraySchema;
+    private readonly item;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: ((src: Src) => false | string)[]);
+    validate(validationFunction: (src: Src) => false | string): ArraySchema<T, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): ArraySchema<T, Src | null>;
+    protected executeSerialize(): SerializedArraySchema;
     private previewInput;
     protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedPreview;
     preview(input: {

package/dist/declarations/src/schema/boolean.d.ts

@@ -1,18 +1,21 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedBooleanSchema = {
     type: "boolean";
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
-    readonly opt: boolean;
-    constructor(opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): BooleanSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): BooleanSchema<Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
-export declare const boolean: () => Schema<boolean>;
+export declare const boolean: () => BooleanSchema<boolean>;

package/dist/declarations/src/schema/date.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SourcePath } from "../val/index.js";
 import { RawString } from "./string.js";
@@ -23,17 +23,20 @@ export type SerializedDateSchema = {
     type: "date";
     options?: DateOptions;
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class DateSchema<Src extends string | null> extends Schema<Src> {
-    readonly options?: DateOptions | undefined;
-    readonly opt: boolean;
-    constructor(options?: DateOptions | undefined, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    private readonly options?;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(options?: DateOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): DateSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     from(from: string): DateSchema<Src>;
     to(to: string): DateSchema<Src>;
     nullable(): DateSchema<Src | null>;
-    serialize(): SerializedSchema;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const date: (options?: Record<string, never>) => DateSchema<RawString>;

package/dist/declarations/src/schema/file.d.ts

@@ -1,6 +1,6 @@
 import { Json } from "../Json.js";
 import { FileSource } from "../source/file.js";
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 import { RemoteSource } from "../index.js";
@@ -13,20 +13,23 @@ export type SerializedFileSchema = {
     options?: FileOptions;
     remote?: boolean;
     opt: boolean;
+    customValidate?: boolean;
 };
 export type FileMetadata = {
     mimeType?: string;
 };
 export declare class FileSchema<Src extends FileSource<FileMetadata | undefined> | RemoteSource<FileMetadata | undefined> | null> extends Schema<Src> {
-    readonly options?: FileOptions | undefined;
-    readonly opt: boolean;
+    private readonly options?;
+    private readonly opt;
     protected readonly isRemote: boolean;
-    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean);
+    private readonly customValidateFunctions;
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
     remote(): FileSchema<Src | RemoteSource<FileMetadata | undefined>>;
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    validate(validationFunction: CustomValidateFunction<Src>): FileSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): FileSchema<Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const file: (options?: FileOptions) => FileSchema<FileSource<FileMetadata>>;

package/dist/declarations/src/schema/image.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { FileSource } from "../source/file.js";
 import { ImageSource } from "../source/image.js";
 import { SourcePath } from "../val/index.js";
@@ -17,6 +17,7 @@ export type SerializedImageSchema = {
     options?: ImageOptions;
     opt: boolean;
     remote?: boolean;
+    customValidate?: boolean;
 };
 export type ImageMetadata = FileMetadata & {
     width: number;
@@ -28,15 +29,17 @@ export type ImageMetadata = FileMetadata & {
     };
 };
 export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefined> | RemoteSource<ImageMetadata | undefined> | null> extends Schema<Src> {
-    readonly options?: ImageOptions | undefined;
-    readonly opt: boolean;
+    private readonly options?;
+    private readonly opt;
     protected readonly isRemote: boolean;
-    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean);
+    private readonly customValidateFunctions;
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
     remote(): ImageSchema<Src | RemoteSource<ImageMetadata | undefined>>;
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    validate(validationFunction: CustomValidateFunction<Src>): ImageSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): ImageSchema<Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const image: (options?: ImageOptions) => ImageSchema<ImageSource>;

package/dist/declarations/src/schema/index.d.ts

@@ -13,7 +13,7 @@ import { SerializedRichTextSchema } from "./richtext.js";
 import { RawString, SerializedStringSchema } from "./string.js";
 import { SerializedUnionSchema } from "./union.js";
 import { SerializedDateSchema } from "./date.js";
-import { ValidationErrors } from "./validation/ValidationError.js";
+import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 import { FileSource } from "../source/file.js";
 import { GenericRichTextSourceNode, RichTextSource } from "../source/richtext.js";
 import { ReifiedPreview } from "../preview.js";
@@ -40,9 +40,11 @@ export type SchemaAssertResult<Src extends SelectorSource> = {
     success: false;
     errors: Record<SourcePath, AssertError[]>;
 };
+export type CustomValidateFunction<Src extends SelectorSource> = (src: Src) => false | string;
 export declare abstract class Schema<Src extends SelectorSource> {
     /** Validate the value of source content */
-    abstract validate(path: SourcePath, src: Src): ValidationErrors;
+    protected abstract executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeCustomValidateFunctions(src: Src, customValidateFunctions: CustomValidateFunction<Src>[]): ValidationError[];
     /**
      * Check if the **root** **type** of source is correct.
      *
@@ -58,12 +60,12 @@ export declare abstract class Schema<Src extends SelectorSource> {
      * When using assert, you must assert recursively if you want to verify the entire source.
      * For example, if you have an object schema, you must assert each key / value pair manually.
      */
-    abstract assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    protected abstract executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     abstract nullable(): Schema<Src | null>;
-    abstract serialize(): SerializedSchema;
+    protected abstract executeSerialize(): SerializedSchema;
     protected abstract executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedPreview;
     /** MUTATES! since internal and perf sensitive */
-    protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value: unknown): ValidationErrors;
+    protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value: unknown, schemaError?: boolean): ValidationErrors;
 }
 export type SelectorOfSchema<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;
 export {};

package/dist/declarations/src/schema/keyOf.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ValModuleBrand } from "../module.js";
 import { GenericSelector } from "../selector/index.js";
 import { Source, SourceObject } from "../source/index.js";
@@ -12,18 +12,21 @@ export type SerializedKeyOfSchema = {
     schema: SerializedSchema;
     opt: boolean;
     values: "string" | string[];
+    customValidate?: boolean;
 };
 type KeyOfSelector<Sel extends GenericSelector<SourceObject>> = Sel extends GenericSelector<infer S> ? S extends readonly Source[] ? number : S extends SourceObject ? string extends keyof S ? RawString : keyof S : S extends Record<string, Source> ? RawString : never : never;
 export declare class KeyOfSchema<Sel extends GenericSelector<SourceObject>, Src extends KeyOfSelector<Sel> | null> extends Schema<Src> {
-    readonly schema?: SerializedSchema | undefined;
-    readonly sourcePath?: SourcePath | undefined;
-    readonly opt: boolean;
-    constructor(schema?: SerializedSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    private readonly schema?;
+    private readonly sourcePath?;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(schema?: SerializedSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): KeyOfSchema<Sel, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): KeyOfSchema<Sel, Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
-export declare const keyOf: <Src extends GenericSelector<SourceObject, undefined> & ValModuleBrand>(valModule: Src) => Schema<KeyOfSelector<Src>>;
+export declare const keyOf: <Src extends GenericSelector<SourceObject, undefined> & ValModuleBrand>(valModule: Src) => KeyOfSchema<Src, KeyOfSelector<Src>>;
 export {};

package/dist/declarations/src/schema/literal.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -6,15 +6,18 @@ export type SerializedLiteralSchema = {
     type: "literal";
     value: string;
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class LiteralSchema<Src extends string | null> extends Schema<Src> {
-    readonly value: string;
-    readonly opt: boolean;
-    constructor(value: string, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    private readonly value;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(value: string, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): LiteralSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): LiteralSchema<Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const literal: <T extends string>(value: T) => LiteralSchema<T>;

package/dist/declarations/src/schema/number.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -10,17 +10,20 @@ export type SerializedNumberSchema = {
     type: "number";
     options?: NumberOptions;
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class NumberSchema<Src extends number | null> extends Schema<Src> {
-    readonly options?: NumberOptions | undefined;
-    readonly opt: boolean;
-    constructor(options?: NumberOptions | undefined, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src>;
+    private readonly options?;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(options?: NumberOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): NumberSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): NumberSchema<Src | null>;
     max(max: number): NumberSchema<Src>;
     min(min: number): NumberSchema<Src>;
-    serialize(): SerializedSchema;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const number: (options?: NumberOptions) => NumberSchema<number>;

package/dist/declarations/src/schema/object.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SelectorSource } from "../selector/index.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
@@ -7,6 +7,7 @@ export type SerializedObjectSchema = {
     type: "object";
     items: Record<string, SerializedSchema>;
     opt: boolean;
+    customValidate?: boolean;
 };
 type ObjectSchemaProps = {
     [key: string]: Schema<SelectorSource>;
@@ -30,14 +31,16 @@ type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
     [key in keyof Props]: SelectorOfSchema<Props[key]>;
 };
 export declare class ObjectSchema<Props extends ObjectSchemaProps, Src extends ObjectSchemaSrcOf<Props> | null> extends Schema<Src> {
-    readonly items: Props;
-    readonly opt: boolean;
-    constructor(items: Props, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    private readonly items;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(items: Props, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): ObjectSchema<Props, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): ObjectSchema<Props, Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedPreview;
 }
-export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SelectorOfSchema<Props[key]>; }>;
+export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => ObjectSchema<Props, ObjectSchemaSrcOf<Props>>;
 export {};

package/dist/declarations/src/schema/record.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { PreviewSelector, ReifiedPreview } from "../preview.js";
 import { SelectorSource } from "../selector/index.js";
 import { ImageSource } from "../source/image.js";
@@ -10,15 +10,18 @@ export type SerializedRecordSchema = {
     type: "record";
     item: SerializedSchema;
     opt: boolean;
+    customValidate?: boolean;
 };
 export declare class RecordSchema<T extends Schema<SelectorSource>, Src extends Record<string, SelectorOfSchema<T>> | null> extends Schema<Src> {
-    readonly item: T;
-    readonly opt: boolean;
-    constructor(item: T, opt?: boolean);
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedRecordSchema;
+    private readonly item;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    validate(validationFunction: (src: Src) => false | string): RecordSchema<T, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): RecordSchema<T, Src | null>;
+    executeSerialize(): SerializedRecordSchema;
     private previewInput;
     protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedPreview;
     preview(input: {

package/dist/declarations/src/schema/richtext.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { ImageSource } from "../source/image.js";
 import { RichTextSource, RichTextOptions, SerializedRichTextOptions } from "../source/richtext.js";
@@ -13,19 +13,22 @@ export type SerializedRichTextSchema = {
     type: "richtext";
     opt: boolean;
     options?: SerializedRichTextOptions & ValidationOptions;
+    customValidate?: boolean;
 };
 export declare class RichTextSchema<O extends RichTextOptions, Src extends RichTextSource<O> | null> extends Schema<Src> {
-    readonly options: O & ValidationOptions;
-    readonly opt: boolean;
-    constructor(options: O & ValidationOptions, opt?: boolean);
+    private readonly options;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    constructor(options: O & ValidationOptions, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
     maxLength(max: number): RichTextSchema<O, Src>;
     minLength(min: number): RichTextSchema<O, Src>;
-    validate(path: SourcePath, src: Src): ValidationErrors;
+    validate(validationFunction: (src: Src) => false | string): RichTextSchema<O, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
     private internalValidate;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     private recursiveAssert;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
+    nullable(): RichTextSchema<O, Src | null>;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const richtext: <O extends Partial<{

package/dist/declarations/src/schema/string.d.ts

@@ -6,6 +6,7 @@ type StringOptions = {
     maxLength?: number;
     minLength?: number;
     regexp?: RegExp;
+    regExpMessage?: string;
 };
 export type SerializedStringSchema = {
     type: "string";
@@ -13,22 +14,26 @@ export type SerializedStringSchema = {
         maxLength?: number;
         minLength?: number;
         regexp?: {
+            message?: string;
             source: string;
             flags: string;
         };
+        customValidate?: boolean;
     };
     opt: boolean;
     raw: boolean;
+    customValidate?: boolean;
 };
 declare const brand: unique symbol;
 export type RawString = string & {
     readonly [brand]: "raw";
 };
 export declare class StringSchema<Src extends string | null> extends Schema<Src> {
-    readonly options?: StringOptions | undefined;
-    readonly opt: boolean;
+    private readonly options?;
+    private readonly opt;
     private readonly isRaw;
-    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean);
+    private readonly customValidateFunctions;
+    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[]);
     /**
      * @deprecated Use `minLength` instead
      */
@@ -39,12 +44,13 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
      */
     max(maxLength: number): StringSchema<Src>;
     maxLength(maxLength: number): StringSchema<Src>;
-    regexp(regexp: RegExp): StringSchema<Src>;
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    regexp(regexp: RegExp, message?: string): StringSchema<Src>;
+    validate(validationFunction: (src: Src) => false | string): StringSchema<Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): StringSchema<Src | null>;
     raw(): StringSchema<Src extends null ? RawString | null : RawString>;
-    serialize(): SerializedSchema;
+    protected executeSerialize(): SerializedSchema;
     protected executePreview(): ReifiedPreview;
 }
 export declare const string: <T extends string>(options?: Record<string, never>) => StringSchema<T>;

package/dist/declarations/src/schema/union.d.ts

@@ -1,4 +1,4 @@
-import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ReifiedPreview } from "../preview.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
@@ -12,12 +12,14 @@ export type SerializedStringUnionSchema = {
     key: SerializedLiteralSchema;
     items: SerializedLiteralSchema[];
     opt: boolean;
+    customValidate?: boolean;
 };
 export type SerializedObjectUnionSchema = {
     type: "union";
     key: string;
     items: SerializedObjectSchema[];
     opt: boolean;
+    customValidate?: boolean;
 };
 type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
     [k in Key]: string;
@@ -25,14 +27,16 @@ type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends
 export declare class UnionSchema<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
     [k in Key]: string;
 } : Key extends Schema<string> ? string : unknown>[], Src extends SourceOf<Key, T> | null> extends Schema<Src> {
-    readonly key: Key;
-    readonly items: T;
-    readonly opt: boolean;
-    validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
-    nullable(): Schema<Src | null>;
-    serialize(): SerializedSchema;
-    constructor(key: Key, items: T, opt?: boolean);
+    private readonly key;
+    private readonly items;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    validate(validationFunction: (src: Src) => false | string): UnionSchema<Key, T, Src>;
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): UnionSchema<Key, T, Src | null>;
+    protected executeSerialize(): SerializedSchema;
+    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
     protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedPreview;
 }
 export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? {
@@ -45,5 +49,5 @@ export declare const union: <Key extends string | Schema<string>, T extends Sche
     _type?: undefined;
     val?: undefined;
     valPath?: undefined;
-} & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
+} & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => UnionSchema<Key, T, SourceOf<Key, T>>;
 export {};

package/dist/declarations/src/source/remote.d.ts

@@ -11,7 +11,7 @@ export type RemoteSource<Metadata extends FileMetadata | undefined = FileMetadat
     readonly metadata?: Metadata;
     readonly patch_id?: string;
 };
-export declare const initRemote: (config?: ValConfig) => <Metadata extends ImageMetadata | FileMetadata>(ref: RemoteRef, metadata: Metadata) => RemoteSource<Metadata>;
+export declare const initRemote: (config?: ValConfig) => <Metadata extends FileMetadata | ImageMetadata>(ref: RemoteRef, metadata: Metadata) => RemoteSource<Metadata>;
 export type RemoteRef = `${string}/file/p/${string}/v/${string}/h/${string}/f/${string}/p/public/val/${string}`;
 export declare function createRemoteRef(remoteHost: string, { publicProjectId, coreVersion, validationHash, fileHash, filePath, bucket, }: {
     publicProjectId: string;