@valbuild/core 0.14.0 → 0.16.0

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

@@ -8,6 +8,8 @@ export type { RemoteSource } from "./source/remote.js";
 export type { RichTextSource, RichText, TextNode, ParagraphNode, HeadingNode, ListItemNode, ListNode, } from "./source/richtext.js";
 export { type Val, type SerializedVal, type ModuleId, type ModulePath, type SourcePath, type JsonOfSource, } from "./val/index.js";
 export type { Json, JsonPrimitive } from "./Json.js";
+export type { ValidationErrors, ValidationError, } from "./schema/validation/ValidationError.js";
+export type { ValidationFix } from "./schema/validation/ValidationFix.js";
 export * as expr from "./expr/index.js";
 export { FILE_REF_PROP } from "./source/file.js";
 export { VAL_EXTENSION, type SourceArray } from "./source/index.js";

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

@@ -29,7 +29,7 @@ type NarrowStrings<A> = (A extends [] ? [] : never) | (A extends string ? A : ne
 export declare const initVal: <Locales extends readonly string[] | undefined>(options?: {
     readonly locales?: {
         readonly required: NarrowStrings<Locales>;
-        readonly fallback: NarrowStrings<Locales extends readonly string[] ? Locales[number] : never>;
+        readonly default: NarrowStrings<Locales extends readonly string[] ? Locales[number] : never>;
     } | undefined;
 } | undefined) => InitVal<Locales>;
 export {};

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

@@ -3,4 +3,4 @@ export { type OperationJSON, type Operation } from "./operation.js";
 export { parsePatch, parseJSONPointer, formatJSONPointer } from "./parse.js";
 export { type JSONValue, type Ops, PatchError } from "./ops.js";
 export { type PatchJSON, type Patch, applyPatch } from "./patch.js";
-export { isNotRoot, deepEqual, deepClone, parseAndValidateArrayIndex, } from "./util.js";
+export { isNotRoot, deepEqual, deepClone, parseAndValidateArrayIndex, sourceToPatchPath, } from "./util.js";

package/dist/declarations/src/patch/util.d.ts

@@ -1,6 +1,8 @@
 import { array, result } from "../fp/index.js";
 import { PatchError, ReadonlyJSONValue, ToMutable } from "./ops.js";
+import { SourcePath } from "../val/index.js";
 export declare function isNotRoot(path: string[]): path is array.NonEmptyArray<string>;
 export declare function deepEqual(a: ReadonlyJSONValue, b: ReadonlyJSONValue): boolean;
 export declare function deepClone<T extends ReadonlyJSONValue>(value: T): ToMutable<T>;
 export declare function parseAndValidateArrayIndex(value: string): result.Result<number, PatchError>;
+export declare function sourceToPatchPath(sourcePath: SourcePath): any[];

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

@@ -1,6 +1,7 @@
 import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedArraySchema = {
     type: "array";
     item: SerializedSchema;
@@ -10,8 +11,8 @@ export declare class ArraySchema<T extends Schema<SelectorSource>> extends Schem
     readonly item: T;
     readonly opt: boolean;
     constructor(item: T, opt?: boolean);
-    validate(src: SchemaTypeOf<T>[]): false | Record<SourcePath, string[]>;
-    match(src: SchemaTypeOf<T>[]): boolean;
+    validate(path: SourcePath, src: SchemaTypeOf<T>[]): ValidationErrors;
+    assert(src: SchemaTypeOf<T>[]): boolean;
     optional(): Schema<SchemaTypeOf<T>[] | null>;
     serialize(): SerializedArraySchema;
 }

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

@@ -1,5 +1,6 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedBooleanSchema = {
     type: "boolean";
     opt: boolean;
@@ -7,8 +8,8 @@ export type SerializedBooleanSchema = {
 export declare class BooleanSchema<Src extends boolean | null> extends Schema<Src> {
     readonly opt: boolean;
     constructor(opt?: boolean);
-    validate(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,6 +1,7 @@
 import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
 import { I18nCompatibleSource, I18nSource } from "../source/i18n.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedI18nSchema = {
     type: "i18n";
     locales: readonly string[];
@@ -12,8 +13,8 @@ export declare class I18nSchema<Locales extends readonly string[]> extends Schem
     readonly item: Schema<SchemaTypeOf<Schema<I18nCompatibleSource>>>;
     readonly opt: boolean;
     constructor(locales: Locales, item: Schema<SchemaTypeOf<Schema<I18nCompatibleSource>>>, opt?: boolean);
-    validate(src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): false | Record<SourcePath, string[]>;
-    match(src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): boolean;
+    validate(path: SourcePath, src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): ValidationErrors;
+    assert(src: I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>>): boolean;
     optional(): Schema<I18nSource<Locales, SchemaTypeOf<Schema<I18nCompatibleSource>>> | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,6 +1,7 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { FileSource } from "../source/file.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type ImageOptions = {
     ext: ["jpg"] | ["webp"];
     directory?: string;
@@ -20,8 +21,8 @@ export declare class ImageSchema<Src extends FileSource<ImageMetadata> | null> e
     readonly options?: ImageOptions | undefined;
     readonly opt: boolean;
     constructor(options?: ImageOptions | undefined, opt?: boolean);
-    validate(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -12,12 +12,15 @@ import { SerializedOneOfSchema } from "./oneOf.js";
 import { SerializedRichTextSchema } from "./richtext.js";
 import { SerializedStringSchema } from "./string.js";
 import { SerializedUnionSchema } from "./union.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedOneOfSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedImageSchema | SerializedI18nSchema;
 export declare abstract class Schema<Src extends SelectorSource> {
-    abstract validate(src: Src): false | Record<SourcePath, string[]>;
-    abstract match(src: Src): boolean;
+    abstract validate(path: SourcePath, src: Src): ValidationErrors;
+    abstract assert(src: Src): boolean;
     abstract optional(): Schema<Src | null>;
     abstract serialize(): SerializedSchema;
     remote(): Src extends RemoteCompatibleSource ? Schema<RemoteSource<Src>> : never;
+    /** MUTATES! since internal and perf sensitive */
+    protected appendValidationError(current: ValidationErrors, path: SourcePath, message: string, value?: unknown): ValidationErrors;
 }
 export type SchemaTypeOf<T extends Schema<SelectorSource>> = T extends Schema<infer Src> ? Src : never;

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

@@ -1,5 +1,6 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedLiteralSchema = {
     type: "literal";
     value: string;
@@ -9,8 +10,8 @@ export declare class LiteralSchema<Src extends string | null> extends Schema<Src
     readonly value: string;
     readonly opt: boolean;
     constructor(value: string, opt?: boolean);
-    validate(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,5 +1,6 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 type NumberOptions = {
     max?: number;
     min?: number;
@@ -13,8 +14,8 @@ 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(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,6 +1,7 @@
 import { Schema, SchemaTypeOf, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedObjectSchema = {
     type: "object";
     items: Record<string, SerializedSchema>;
@@ -16,8 +17,8 @@ export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schem
     readonly items: Props;
     readonly opt: boolean;
     constructor(items: Props, opt?: boolean);
-    validate(src: ObjectSchemaSrcOf<Props>): false | Record<SourcePath, string[]>;
-    match(src: ObjectSchemaSrcOf<Props>): boolean;
+    validate(path: SourcePath, src: ObjectSchemaSrcOf<Props>): ValidationErrors;
+    assert(src: ObjectSchemaSrcOf<Props>): boolean;
     optional(): Schema<ObjectSchemaSrcOf<Props> | null>;
     serialize(): SerializedSchema;
 }

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

@@ -3,6 +3,7 @@ import { ValModuleBrand } from "../module.js";
 import { GenericSelector } from "../selector/index.js";
 import { Source, SourceArray } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedOneOfSchema = {
     type: "oneOf";
     selector: SourcePath;
@@ -13,8 +14,8 @@ export declare class OneOfSchema<Sel extends GenericSelector<SourceArray>> exten
     readonly selector: Sel;
     readonly opt: boolean;
     constructor(selector: Sel, opt?: boolean);
-    validate(src: OneOfSelector<Sel>): false | Record<SourcePath, string[]>;
-    match(src: OneOfSelector<Sel>): boolean;
+    validate(path: SourcePath, src: OneOfSelector<Sel>): ValidationErrors;
+    assert(src: OneOfSelector<Sel>): boolean;
     optional(): Schema<OneOfSelector<Sel> | null>;
     serialize(): SerializedSchema;
 }

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

@@ -1,14 +1,15 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { RichTextSource } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedRichTextSchema = {
     type: "richtext";
     opt: boolean;
 };
 export declare class RichTextSchema<Src extends RichTextSource | null> extends Schema<Src> {
     readonly opt: boolean;
-    validate(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<RichTextSource | null>;
     serialize(): SerializedSchema;
     constructor(opt?: boolean);

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

@@ -1,5 +1,6 @@
 import { Schema, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
     maxLength?: number;
     minLength?: number;
@@ -13,8 +14,8 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     readonly options?: StringOptions | undefined;
     readonly opt: boolean;
     constructor(options?: StringOptions | undefined, opt?: boolean);
-    validate(src: Src): false | Record<SourcePath, string[]>;
-    match(src: Src): boolean;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(src: Src): boolean;
     optional(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }

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

@@ -2,6 +2,7 @@ import { Schema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
+import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedUnionSchema = {
     type: "union";
     key: string;
@@ -17,8 +18,8 @@ export declare class UnionSchema<Key extends string, T extends Schema<SourceObje
     readonly key: Key;
     readonly items: T;
     readonly opt: boolean;
-    validate(src: SourceOf<Key, T>): false | Record<SourcePath, string[]>;
-    match(src: SourceOf<Key, T>): boolean;
+    validate(path: SourcePath, src: SourceOf<Key, T>): ValidationErrors;
+    assert(src: SourceOf<Key, T>): boolean;
     optional(): Schema<SourceOf<Key, T> | null>;
     serialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean);

package/dist/declarations/src/schema/validation/ValidationError.d.ts

@@ -0,0 +1,14 @@
+import { SourcePath } from "../../val/index.js";
+import { ValidationFix } from "./ValidationFix.js";
+export type ValidationError = {
+    message: string;
+    value?: unknown;
+    fixes?: ValidationFix[];
+};
+/**
+ * Equals `false` if no validation errors were found.
+ * Errors are indexed by the full source path.
+ *
+ * Global errors have the path `"/"`.
+ */
+export type ValidationErrors = false | Record<SourcePath, ValidationError[]>;

package/dist/declarations/src/schema/validation/ValidationFix.d.ts

@@ -0,0 +1,2 @@
+export declare const ValidationFix: readonly ["image:add-metadata", "image:replace-metadata"];
+export type ValidationFix = (typeof ValidationFix)[number];