@valbuild/core 0.125.0 → 0.127.0

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

@@ -1,93 +1,56 @@
-import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { ItemPreviewInput, PreviewItem, ReifiedPreview, PreviewScope } from "../preview.js";
-import { FieldRender } from "../render.js";
+import { Schema } from "./index.js";
 import { SelectorSource } from "../selector/index.js";
-import { SourceObject } from "../source/index.js";
-import { ModuleFilePath, SourcePath } from "../val/index.js";
-import { SerializedLiteralSchema } from "./literal.js";
-import { SerializedObjectSchema } from "./object.js";
-import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
-export type SerializedUnionSchema = SerializedStringUnionSchema | SerializedObjectUnionSchema;
-export type SerializedStringUnionSchema = {
-    type: "union";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
-    /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
-    preview?: true;
-    key: SerializedLiteralSchema;
-    items: SerializedLiteralSchema[];
-    opt: boolean;
-    customValidate?: boolean;
-    readonly?: boolean;
-    hidden?: boolean;
-    description?: string;
-};
-export type SerializedObjectUnionSchema = {
-    type: "union";
-    /** Static layout config, carried whole in the serialized schema — see `render.ts`. */
-    render?: FieldRender;
-    /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
-    preview?: true;
-    key: string;
-    items: SerializedObjectSchema[];
-    opt: boolean;
-    customValidate?: boolean;
-    readonly?: boolean;
-    hidden?: boolean;
-    description?: string;
-};
-type SourceOf<Key extends string | Schema<string>, T extends Schema<Key extends string ? SourceObject & {
-    [k in Key]: string;
-} : 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>[], Src extends SourceOf<Key, T> | null> extends Schema<Src> {
-    private readonly key;
-    private readonly items;
-    private readonly opt;
-    private readonly customValidateFunctions;
-    private readonly isReadonly;
-    private readonly isHidden;
-    private readonly description?;
-    private readonly renderInput;
-    private readonly previewInput;
-    describe(description: string | null): UnionSchema<Key, T, Src>;
-    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>;
-    readonly(isReadonly?: boolean): UnionSchema<Key, T, Src>;
-    hidden(isHidden?: boolean): UnionSchema<Key, T, Src>;
-    protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
-    /**
-     * The variant schema a value takes, for a TAGGED union (string `key`). `null`
-     * for a literal union (its variants are leaves with nothing to descend into) or
-     * when the value matches none of them — a structural error `executeValidate`
-     * already reports.
-     */
-    private matchedVariant;
-    /**
-     * How this field is laid out in the editor when it is the item of an array
-     * or record: `{ as: "inline" }` renders the field itself inside each row,
-     * instead of a preview row that navigates to it.
-     *
-     * Static configuration, not a callback — see `render.ts`.
-     */
-    render(input: FieldRender): UnionSchema<Key, T, Src>;
-    /**
-     * How this VALUE is shown where a preview of it is needed — a row in a
-     * sortable list, a reference dropdown, a search hit. Never how the field
-     * itself is edited (that is `render`). See `preview.ts`.
-     *
-     * Without one of its own, a tagged union previews as the VARIANT the value
-     * takes — declare `preview` on the member objects and the union dispatches.
-     */
-    preview(select: ItemPreviewInput<Src>): UnionSchema<Key, T, Src>;
-    protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;
-    protected declaresItemPreview(): boolean;
-    protected executeSerialize(): SerializedSchema;
-    constructor(key: Key, items: T, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
-    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>>;
+import { DiscriminatedUnionItems, DiscriminatedUnionSchema, DiscriminatedUnionSourceOf, SerializedDiscriminatedUnionSchema } from "./discriminatedUnion.js";
+import { EnumSchema, SerializedEnumSchema } from "./enum.js";
+/**
+ * @deprecated Use {@link SerializedDiscriminatedUnionSchema} or
+ * {@link SerializedEnumSchema}. A serialized union is now one or the other,
+ * distinguished by `type` rather than by the shape of `key`.
+ */
+export type SerializedUnionSchema = SerializedDiscriminatedUnionSchema | SerializedEnumSchema;
+/** @deprecated Use {@link SerializedEnumSchema}. */
+export type SerializedStringUnionSchema = SerializedEnumSchema;
+/** @deprecated Use {@link SerializedDiscriminatedUnionSchema}. */
+export type SerializedObjectUnionSchema = SerializedDiscriminatedUnionSchema;
+/**
+ * @deprecated There is no single union schema class any more: name
+ * {@link DiscriminatedUnionSchema} or {@link EnumSchema}. The type parameters
+ * are kept so existing annotations still compile, but only `Src` is used.
+ */
+export type UnionSchema<_Key = unknown, _T = unknown, Src extends SelectorSource = SelectorSource> = Schema<Src>;
+/**
+ * The value type of a list of literal schemas — how `s.union` typed a union of
+ * literals. Inferred from `Schema<infer S>` rather than `LiteralSchema<infer S>`
+ * because a `LiteralSchema` is invariant in its source (its custom validate
+ * functions put it in a parameter position), so `LiteralSchema<"a">` is not
+ * assignable to `LiteralSchema<"a" | "b">`.
+ */
+type EnumSourceOf<T extends Schema<string>[]> = T extends Schema<infer S>[] ? S extends string ? S : never : never;
+/**
+ * @deprecated Use `s.discriminatedUnion(key, ...objects)` for a tagged union of
+ * objects, or `s.enum("a", "b")` for one of a fixed set of strings.
+ *
+ * One thing does NOT survive the literal form: an enum's values are strings,
+ * so a member literal's own `.validate()` and `.describe()` are dropped rather
+ * than carried over. `s.union(s.literal("a").validate(...), ...)` ran that
+ * validator as part of deciding whether the value matched; `s.enum` has no
+ * member to run. A validator on a single-valued literal could only accept or
+ * reject that one value, which the enum's own value list already decides — but
+ * if you rely on one, keep it by validating the enum itself.
+ *
+ * @example
+ * // was: s.union("type", s.object({ type: s.literal("a"), a: s.string() }))
+ * const schema = s.discriminatedUnion(
+ *   "type",
+ *   s.object({ type: s.literal("a"), a: s.string() }),
+ * );
+ * export default c.define("/example.val.ts", schema, { type: "a", a: "one" });
+ *
+ * @example
+ * // was: s.union(s.literal("a"), s.literal("b"))
+ * const schema = s.enum("a", "b");
+ * export default c.define("/example.val.ts", schema, "a");
+ */
+export declare function union<Key extends string, T extends DiscriminatedUnionItems<Key>>(key: Key, ...objects: T): DiscriminatedUnionSchema<Key, T, DiscriminatedUnionSourceOf<Key, T>>;
+export declare function union<T extends Schema<string>[]>(...literals: T): EnumSchema<EnumSourceOf<T>>;
 export {};

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

@@ -1,2 +1,2 @@
-export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "keyof:check-keys", "router:check-route", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "jsonValues:extract-entry", "external:upload"];
+export declare const ValidationFix: readonly ["image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "images:check-remote", "images:upload-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "files:check-remote", "files:upload-remote", "keyof:check-keys", "router:check-route", "locale:check-locale", "images:check-unique-folder", "files:check-unique-folder", "images:check-all-files", "files:check-all-files", "jsonValues:extract-entry", "record:fill-keys", "external:upload"];
 export type ValidationFix = (typeof ValidationFix)[number];

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

@@ -22,6 +22,41 @@
  */
 export type SettingsSource = {
     assistant?: AssistantSettingsSource;
+    locales?: LocalesSettingsSource;
+};
+/**
+ * The languages this project publishes.
+ *
+ * Content rather than configuration, and deliberately: which languages a site
+ * has is a decision the people who write it make, and under a build-time
+ * constant it took a developer and a deploy. It is the same move `assistant`
+ * makes with `enabled`.
+ *
+ * Val ships no list of its own. A project with no `locales` section has not
+ * said it is translated, and nothing about locales appears anywhere — no picker
+ * in the Studio, no checks, nothing.
+ *
+ * **This list is a decision with a blast radius.** Every locale in content is
+ * checked against it, so removing one invalidates the content that uses it, and
+ * adding one leaves every locale-keyed record short of a language until it is
+ * filled in. That is the intended behaviour — a language that is declared and
+ * missing everywhere is worth being told about — but it is why the Studio warns
+ * before saving a removal rather than treating this as an ordinary field.
+ *
+ * There is no default language, deliberately. Every locale-specific field asks
+ * which language it is in, and a default is exactly the answer that lets that
+ * question go unanswered — content ends up filed under a language nobody chose,
+ * which is the state translation is meant to make visible.
+ */
+export type LocalesSettingsSource = {
+    /**
+     * The languages, as canonical BCP 47 tags: `en-US`, `nb-NO`.
+     *
+     * Order is the project's own, and it is kept: it decides the order of the
+     * Studio's picker and of the rows in a locale-keyed record, so a project can
+     * put the language it works in first.
+     */
+    available?: string[] | null;
 };
 /**
  * The assistant: whether editors have one, and what it is told about the
@@ -55,6 +90,22 @@ export type AssistantSettingsSource = {
      * `glossary`) rather than a field that looks like it should absorb them.
      */
     tone?: string | null;
+    /**
+     * How to translate into each language, keyed by language.
+     *
+     * Per language rather than one field, because translation rules are per
+     * language: bokmål or nynorsk, `du` or `De`, which product names stay in
+     * English. Only the target language's note is sent, so a French rule does not
+     * ride along in a Norwegian request.
+     *
+     * Keyed by language, so it holds every one of them once it exists at all —
+     * `null` where a language needs no special instruction, which is most of them.
+     * That is the same rule every locale-keyed record follows (see
+     * `declaredKeys.ts`): a gap you can count and see in a diff, rather than a key
+     * that is simply not there. A project with no notes at all leaves the whole
+     * field unset and nothing is required.
+     */
+    translation?: Record<string, string | null> | null;
 };
 /**
  * The cap on each of the assistant's prose fields, in characters.