@valbuild/core 0.83.0 → 0.84.0

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

@@ -53,6 +53,7 @@ export { type SerializedUnionSchema, UnionSchema, type SerializedStringUnionSche
 export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js";
 export { deserializeSchema } from "./schema/deserialize.js";
 export { type ListRecordRender, type ListArrayRender, type ReifiedRender, } from "./render.js";
+export type { ValRouter, RouteValidationError } from "./router.js";
 export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
 export type FatalErrorType = (typeof FATAL_ERROR_TYPES)[number];
 export declare const DEFAULT_CONTENT_HOST = "https://content.val.build";
@@ -70,6 +71,7 @@ declare const Internal: {
     safeResolvePath: typeof safeResolvePath;
     splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
     joinModuleFilePathAndModulePath: typeof joinModuleFilePathAndModulePath;
+    nextAppRouter: import("./router.js").ValRouter;
     remote: {
         createRemoteRef: typeof createRemoteRef;
         getValidationBasis: typeof getValidationBasis;

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

@@ -0,0 +1,24 @@
+import { ModuleFilePath } from "./val/index.js";
+export type RouteValidationError = {
+    error: {
+        message: string;
+        urlPath: string;
+        expectedPath: string | null;
+    };
+};
+export declare const nextAppRouter: ValRouter;
+/**
+ * Parse Next.js route pattern from file path
+ * Support multiple Next.js app directory structures:
+ * - /app/blogs/[blog]/page.val.ts -> ["blogs", "[blog]"]
+ * - /src/app/blogs/[blog]/page.val.ts -> ["blogs", "[blog]"]
+ * - /pages/blogs/[blog].tsx -> ["blogs", "[blog]"] (Pages Router)
+ * - /app/(group)/blogs/[blog]/page.val.ts -> ["blogs", "[blog]"] (with groups)
+ * - /app/(.)feed/page.val.ts -> ["feed"] (interception route)
+ * - /app/(..)(dashboard)/feed/page.val.ts -> ["feed"] (interception route)
+ */
+export declare function parseNextJsRoutePattern(moduleFilePath: string): string[];
+export interface ValRouter {
+    getRouterId(): string;
+    validate(moduleFilePath: ModuleFilePath, urlPaths: string[]): RouteValidationError[];
+}

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

@@ -40,11 +40,15 @@ export type SchemaAssertResult<Src extends SelectorSource> = {
     success: false;
     errors: Record<SourcePath, AssertError[]>;
 };
-export type CustomValidateFunction<Src extends SelectorSource> = (src: Src) => false | string;
+export type CustomValidateFunction<Src extends SelectorSource> = (src: Src, ctx: {
+    path: SourcePath;
+}) => false | string;
 export declare abstract class Schema<Src extends SelectorSource> {
     /** Validate the value of source content */
     protected abstract executeValidate(path: SourcePath, src: Src): ValidationErrors;
-    protected executeCustomValidateFunctions(src: Src, customValidateFunctions: CustomValidateFunction<Src>[]): ValidationError[];
+    protected executeCustomValidateFunctions(src: Src, customValidateFunctions: CustomValidateFunction<Src>[], ctx: {
+        path: SourcePath;
+    }): ValidationError[];
     /**
      * Check if the **root** **type** of source is correct.
      *

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

@@ -9,18 +9,26 @@ import { ReifiedRender } from "../render.js";
 export type SerializedKeyOfSchema = {
     type: "keyOf";
     path: SourcePath;
-    schema: SerializedSchema;
+    schema?: SerializedRefSchema | undefined;
     opt: boolean;
     values: "string" | string[];
     customValidate?: boolean;
 };
+type SerializedRefSchema = {
+    type: "object";
+    keys: string[];
+    opt?: boolean | undefined;
+} | {
+    type: "record";
+    opt?: boolean | undefined;
+};
 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> {
     private readonly schema?;
     private readonly sourcePath?;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(schema?: SerializedSchema | undefined, sourcePath?: SourcePath | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    constructor(schema?: SerializedRefSchema | 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>;

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

@@ -1,5 +1,6 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
 import { RenderSelector, ReifiedRender } from "../render.js";
+import { ValRouter } from "../router.js";
 import { SelectorSource } from "../selector/index.js";
 import { ImageSource } from "../source/image.js";
 import { RemoteSource } from "../source/remote.js";
@@ -10,18 +11,22 @@ export type SerializedRecordSchema = {
     type: "record";
     item: SerializedSchema;
     opt: boolean;
+    router?: string;
     customValidate?: boolean;
 };
 export declare class RecordSchema<T extends Schema<SelectorSource>, Src extends Record<string, SelectorOfSchema<T>> | null> extends Schema<Src> {
     private readonly item;
     private readonly opt;
     private readonly customValidateFunctions;
-    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[]);
+    private readonly currentRouter;
+    constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null);
     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;
+    router(router: ValRouter): RecordSchema<T, Src>;
+    private getRouterValidations;
+    protected executeSerialize(): SerializedRecordSchema;
     private renderInput;
     protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src): ReifiedRender;
     render(input: {