@valbuild/core 0.63.6 → 0.65.0

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

@@ -1,4 +1,4 @@
-import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -28,13 +28,13 @@ type ObjectSchemaProps = {
 type ObjectSchemaSrcOf<Props extends ObjectSchemaProps> = {
     [key in keyof Props]: SelectorOfSchema<Props[key]>;
 };
-export declare class ObjectSchema<Props extends ObjectSchemaProps> extends Schema<ObjectSchemaSrcOf<Props>> {
+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: ObjectSchemaSrcOf<Props>): ValidationErrors;
-    assert(src: ObjectSchemaSrcOf<Props>): boolean;
-    nullable(): Schema<ObjectSchemaSrcOf<Props> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
 export declare const object: <Props extends ObjectSchemaProps>(schema: Props) => Schema<{ [key in keyof Props]: SelectorOfSchema<Props[key]>; }>;

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

@@ -1,4 +1,4 @@
-import { Schema, SelectorOfSchema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
@@ -7,13 +7,13 @@ export type SerializedRecordSchema = {
     item: SerializedSchema;
     opt: boolean;
 };
-export declare class RecordSchema<T extends Schema<SelectorSource>> extends Schema<Record<string, SelectorOfSchema<T>>> {
+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: Record<string, SelectorOfSchema<T>>): ValidationErrors;
-    assert(src: Record<string, SelectorOfSchema<T>>): boolean;
-    nullable(): Schema<Record<string, SelectorOfSchema<T>> | null>;
+    validate(path: SourcePath, src: Src): ValidationErrors;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedRecordSchema;
 }
 export declare const record: <S extends Schema<SelectorSource>>(schema: S) => Schema<Record<string, SelectorOfSchema<S>>>;

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

@@ -1,39 +1,20 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { RichTextSource, RichTextOptions } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 export type SerializedRichTextSchema = {
     type: "richtext";
     opt: boolean;
-    options: RichTextOptions;
+    options?: RichTextOptions;
 };
 export declare class RichTextSchema<O extends RichTextOptions, Src extends RichTextSource<O> | null> extends Schema<Src> {
     readonly options: O;
     readonly opt: boolean;
     constructor(options: O, opt?: boolean);
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
-    nullable(): Schema<RichTextSource<O> | null>;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    private recursiveAssert;
+    nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const richtext: <O extends Partial<{
-    style: Partial<{
-        bold: boolean;
-        italic: boolean;
-        lineThrough: boolean;
-    }>;
-    block: Partial<{
-        h1: boolean;
-        h2: boolean;
-        h3: boolean;
-        h4: boolean;
-        h5: boolean;
-        h6: boolean;
-        ul: boolean;
-        ol: boolean;
-    }>;
-    inline: Partial<{
-        a: boolean;
-        img: boolean;
-    }>;
-}>>(options?: O | undefined) => Schema<RichTextSource<O>>;
+export declare const richtext: <O extends RichTextOptions>(options?: O) => Schema<RichTextSource<O>>;

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

@@ -1,4 +1,4 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
@@ -32,7 +32,7 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     max(maxLength: number): StringSchema<Src>;
     regexp(regexp: RegExp): StringSchema<Src>;
     validate(path: SourcePath, src: Src): ValidationErrors;
-    assert(src: Src): boolean;
+    assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): StringSchema<Src | null>;
     raw(): StringSchema<Src extends null ? RawString | null : RawString>;
     serialize(): SerializedSchema;

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

@@ -1,12 +1,21 @@
-import { Schema, SerializedSchema } from "./index.js";
+import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { SourcePath } from "../val/index.js";
+import { SerializedLiteralSchema } from "./literal.js";
+import { SerializedObjectSchema } from "./object.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
-export type SerializedUnionSchema = {
+export type SerializedUnionSchema = SerializedStringUnionSchema | SerializedObjectUnionSchema;
+export type SerializedStringUnionSchema = {
     type: "union";
-    key: string | SerializedSchema;
-    items: SerializedSchema[];
+    key: SerializedLiteralSchema;
+    items: SerializedLiteralSchema[];
+    opt: boolean;
+};
+export type SerializedObjectUnionSchema = {
+    type: "union";
+    key: string;
+    items: SerializedObjectSchema[];
     opt: boolean;
 };
 type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
@@ -14,25 +23,15 @@ type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends
 } : Key extends Schema<string> ? string : unknown>[]> = T extends Schema<infer S>[] ? S extends SelectorSource ? S | (Key extends Schema<infer K> ? K : never) : never : never;
 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>[]> extends Schema<SourceOf<Key, T>> {
+} : 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: SourceOf<Key, T>): ValidationErrors;
-    assert(src: SourceOf<Key, T>): boolean;
-    nullable(): Schema<SourceOf<Key, T> | null>;
+    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);
 }
-export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? {
-    [x: string]: import("../source/index.js").Source;
-} & {
-    fold?: undefined;
-    assert?: undefined;
-    andThen?: undefined;
-    _ref?: undefined;
-    _type?: undefined;
-    val?: undefined;
-    valPath?: undefined;
-} & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
+export declare const union: <Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & { [k in Key]: string; } : Key extends Schema<string> ? string : unknown>[]>(key: Key, ...objects: T) => Schema<SourceOf<Key, T>>;
 export {};

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

@@ -3,7 +3,8 @@ import { ValidationFix } from "./ValidationFix.js";
 export type ValidationError = {
     message: string;
     value?: unknown;
-    fatal?: boolean;
+    typeError?: boolean;
+    schemaError?: boolean;
     fixes?: ValidationFix[];
 };
 /**

package/dist/declarations/src/selector/SelectorProxy.d.ts

@@ -4,4 +4,5 @@ import { ModulePath, SourcePath } from "../val/index.js";
 export declare function isSelector(source: any): source is GenericSelector<Source>;
 export declare function newSelectorProxy(source: any, path?: SourcePath, moduleSchema?: any): any;
 export declare function createValPathOfItem(arrayPath: SourcePath | ModulePath | undefined, prop: string | number | symbol): SourcePath | undefined;
+export declare function unsafeCreateSourcePath(path: string, itemKey: string | number | symbol): SourcePath;
 export declare function selectorToVal(s: any): any;

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

@@ -1,4 +1,5 @@
 import { VAL_EXTENSION } from "./index.js";
+import { ValConfig } from "../initVal.js";
 import { Json } from "../Json.js";
 export declare const FILE_REF_PROP: "_ref";
 export declare const FILE_REF_SUBTYPE_TAG: "_tag";
@@ -18,8 +19,10 @@ export type FileSource<Metadata extends FileMetadata | undefined = FileMetadata
     readonly metadata?: Metadata;
     readonly patch_id?: string;
 };
-export declare function file<Metadata extends {
-    readonly [key: string]: Json;
-}>(ref: `/public/${string}`, metadata: Metadata): FileSource<Metadata>;
-export declare function file(ref: `/public/${string}`, metadata?: undefined): FileSource<undefined>;
+export declare const initFile: (config?: ValConfig) => {
+    <Metadata extends {
+        readonly [key: string]: Json;
+    }>(ref: `${`/public/${string}`}/${string}`, metadata: Metadata): FileSource<Metadata>;
+    (ref: `${`/public/${string}`}/${string}`, metadata?: undefined): FileSource<undefined>;
+};
 export declare function isFile(obj: unknown): obj is FileSource;

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

@@ -48,6 +48,13 @@ export type LineThrough<O extends RichTextOptions> = NonNullable<O["style"]>["li
 export type Italic<O extends RichTextOptions> = NonNullable<O["style"]>["italic"] extends true ? "italic" : never;
 export type Bold<O extends RichTextOptions> = NonNullable<O["style"]>["bold"] extends true ? "bold" : never;
 export type Styles<O extends RichTextOptions> = LineThrough<O> | Italic<O> | Bold<O>;
+export type GenericRichTextSourceNode = {
+    tag: string;
+    styles?: string[];
+    href?: string;
+    src?: ImageSource;
+    children?: (string | GenericRichTextSourceNode)[];
+};
 export type ParagraphNode<O extends RichTextOptions> = {
     tag: "p";
     children: (string | SpanNode<O> | BrNode | LinkNode<O> | ImageNode<O> | CustomInlineNode<O>)[];

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

@@ -22,7 +22,7 @@ export type Val<T extends Json> = Json extends T ? {
     readonly val: Source;
 } : T extends JsonObject ? ObjectVal<T> : T extends JsonArray ? ArrayVal<T> : T extends JsonPrimitive ? PrimitiveVal<T> : never;
 export declare function isVal<T extends Json>(val: unknown): val is Val<T>;
-declare const brand: unique symbol;
+declare const brand = "VAL_DATA_TYPE";
 /**
  * The path of the source value.
  *