@valbuild/core 0.103.0 → 0.105.1

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

@@ -1,8 +1,7 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SelectorOfSchema, SerializedSchema } from "./index.js";
-import { RenderSelector, ReifiedRender, RenderScope } from "../render.js";
+import { PreviewItem, PreviewSelector, ReifiedPreview, PreviewScope } from "../preview.js";
 import { ValRouter } from "../router.js";
 import { SelectorSource } from "../selector/index.js";
-import { ImageSource } from "../source/media.js";
 import { JsonOf, JsonSource } from "../source/json.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -18,8 +17,8 @@ export type SerializedRecordSchema = {
     item: SerializedSchema;
     key?: SerializedSchema;
     opt: boolean;
-    /** Set when this schema declares a `render`. See `SerializedArraySchema`. */
-    render?: true;
+    /** Set when this schema declares a `preview`. See `SerializedArraySchema`. */
+    preview?: true;
     router?: string;
     customValidate?: boolean;
     mediaType?: "files" | "images";
@@ -46,17 +45,10 @@ export type SerializedRecordSchema = {
  * authoring.
  */
 export type JsonValuesRecordSrc<T extends Schema<SelectorSource>, K extends Schema<string>> = Record<SelectorOfSchema<K>, JsonSource<JsonOf<SelectorOfSchema<T>>> | SelectorOfSchema<T>>;
-type RecordRenderInput<T extends Schema<SelectorSource>> = {
-    layout: "list";
-    select: (input: {
-        key: string;
-        val: RenderSelector<T>;
-    }) => {
-        title: string;
-        subtitle?: string | null;
-        image?: ImageSource | null;
-    };
-};
+type RecordPreviewInput<T extends Schema<SelectorSource>> = (input: {
+    key: string;
+    val: PreviewSelector<T>;
+}) => PreviewItem;
 export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Schema<string>, Src extends Record<SelectorOfSchema<K>, SelectorOfSchema<T>> | JsonValuesRecordSrc<T, K> | null> extends Schema<Src> {
     private readonly item;
     private readonly opt;
@@ -69,10 +61,10 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
     private readonly description?;
     /** When true, entry values are lazily loaded {@link JsonSource} thunks. */
     private readonly isJsonValues;
-    private readonly renderInput;
+    private readonly previewInput;
     constructor(item: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], currentRouter?: ValRouter | null, keySchema?: Schema<string> | null, mediaOptions?: MediaOptions | undefined, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, 
     /** When true, entry values are lazily loaded {@link JsonSource} thunks. */
-    isJsonValues?: boolean, renderInput?: RecordRenderInput<T> | null);
+    isJsonValues?: boolean, previewInput?: RecordPreviewInput<T> | null);
     describe(description: string | null): RecordSchema<T, K, Src>;
     validate(validationFunction: (src: Src) => false | string): RecordSchema<T, K, Src>;
     protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
@@ -113,18 +105,16 @@ export declare class RecordSchema<T extends Schema<SelectorSource>, K extends Sc
      * defers).
      */
     validateJsonEntryContent(path: SourcePath, content: SelectorSource): ValidationErrors;
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: RenderScope): ReifiedRender;
-    render(input: {
-        as: "list";
-        select: (input: {
-            key: string;
-            val: RenderSelector<T>;
-        }) => {
-            title: string;
-            subtitle?: string | null;
-            image?: ImageSource | null;
-        };
-    }): RecordSchema<T, K, Src>;
+    protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: PreviewScope): ReifiedPreview;
+    /**
+     * What the editor shows for each ENTRY of this record: a title, and optionally
+     * a subtitle and an image.
+     *
+     * `select` is your own code over the entry's key and source, so it is run on
+     * demand for the entries that are actually being looked at — see
+     * `PreviewScope`.
+     */
+    preview(select: RecordPreviewInput<T>): RecordSchema<T, K, Src>;
 }
 export declare function record<K extends Schema<string>, S extends Schema<SelectorSource>>(key: K, schema: S): RecordSchema<S, K, Record<SelectorOfSchema<K>, SelectorOfSchema<S>>>;
 export declare function record<S extends Schema<SelectorSource>>(schema: S): RecordSchema<S, Schema<string>, Record<string, SelectorOfSchema<S>>>;

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

@@ -1,5 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { ReifiedRender } from "../render.js";
+import { ReifiedPreview } from "../preview.js";
 import { RichTextSource, RichTextOptions, SerializedRichTextOptions } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
@@ -37,7 +37,7 @@ export declare class RichTextSchema<O extends RichTextOptions, Src extends RichT
     hidden(): RichTextSchema<O, Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedSchema;
-    protected executeRender(): ReifiedRender;
+    protected executePreview(): ReifiedPreview;
 }
 export declare const richtext: <O extends RichTextOptions>(options?: O) => RichTextSchema<O, RichTextSource<O>>;
 export {};

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

@@ -1,6 +1,6 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
-import { ReifiedRender } from "../render.js";
+import { ReifiedPreview } from "../preview.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type RouteOptions = {
     include?: RegExp;
@@ -68,7 +68,7 @@ export declare class RouteSchema<Src extends string | null> extends Schema<Src>
     hidden(): RouteSchema<Src>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedSchema;
-    protected executeRender(): ReifiedRender;
+    protected executePreview(): ReifiedPreview;
 }
 export declare const route: <T extends string>(options?: Record<string, never>) => RouteSchema<T>;
 export {};

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

@@ -1,6 +1,7 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { CodeLanguage, ReifiedRender, RenderScope } from "../render.js";
-import { ModuleFilePath, SourcePath } from "../val/index.js";
+import { ReifiedPreview } from "../preview.js";
+import { StringRender } from "../render.js";
+import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
     maxLength?: number;
@@ -10,8 +11,16 @@ type StringOptions = {
 };
 export type SerializedStringSchema = {
     type: "string";
-    /** Set when this schema declares a `render`. See `SerializedArraySchema`. */
-    render?: true;
+    /**
+     * How this field is laid out in the editor, carried WHOLE rather than as a
+     * marker.
+     *
+     * A render is static configuration — no closure, no dependency on source — so
+     * unlike a `preview` it serializes in full, and the editor reads it straight
+     * off the schema it already has. See `render.ts` for what that assumption
+     * buys, and what to do if a render ever needs to stop being static.
+     */
+    render?: StringRender;
     options?: {
         maxLength?: number;
         minLength?: number;
@@ -42,12 +51,7 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     private readonly isReadonly;
     private readonly isHidden;
     private readonly description?;
-    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: {
-        as: "textarea";
-    } | {
-        as: "code";
-        language: CodeLanguage;
-    } | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
+    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: StringRender | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
     describe(description: string | null): StringSchema<Src>;
     /**
      * @deprecated Use `minLength` instead
@@ -69,13 +73,20 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     raw(): StringSchema<Src extends null ? RawString | null : RawString>;
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedSchema;
-    render(input: {
-        as: "textarea";
-    } | {
-        as: "code";
-        language: CodeLanguage;
-    }): StringSchema<Src>;
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, _scope?: RenderScope): ReifiedRender;
+    /**
+     * How this field is laid out in the editor: a textarea, or a code editor for
+     * the given language.
+     *
+     * Static configuration, not a callback — see `render.ts`. What a CONTAINER
+     * shows for its items is a `preview`, which is a different thing entirely.
+     */
+    render(input: StringRender): StringSchema<Src>;
+    /**
+     * Nothing: a string has no items, so there is nothing to preview. Its layout
+     * is a `render`, which travels in the serialized schema instead of through
+     * this pipeline.
+     */
+    protected executePreview(): ReifiedPreview;
 }
 export declare const string: <T extends string>(options?: Record<string, never>) => StringSchema<T>;
 export {};

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

@@ -1,5 +1,5 @@
 import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { ReifiedRender, RenderScope } from "../render.js";
+import { ReifiedPreview, PreviewScope } from "../preview.js";
 import { SelectorSource } from "../selector/index.js";
 import { SourceObject } from "../source/index.js";
 import { ModuleFilePath, SourcePath } from "../val/index.js";
@@ -57,7 +57,7 @@ export declare class UnionSchema<Key extends string | Schema<string>, T extends
     private matchedVariant;
     protected executeSerialize(): SerializedSchema;
     constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined);
-    protected executeRender(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: RenderScope): ReifiedRender;
+    protected executePreview(sourcePath: SourcePath | ModuleFilePath, src: Src, scope?: PreviewScope): ReifiedPreview;
 }
 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) => UnionSchema<Key, T, SourceOf<Key, T>>;
 export {};