@valbuild/core 0.110.0 → 0.117.0

package/CHANGELOG.md

@@ -0,0 +1,56 @@
+# @valbuild/core
+
+## 0.117.0
+
+### Patch Changes
+
+- [#581](https://github.com/valbuild/val/pull/581) [`d94a40f`](https://github.com/valbuild/val/commit/d94a40f8bd11027636d183e293aced820b6f341f) Thanks [@freekh](https://github.com/freekh)! - Images no longer show a validation warning in the editor when nothing is wrong
+  with them.
+
+  Every `s.image()` carrying width, height or a mime type used to be marked in VS
+  Code with "Found image metadata, but it could not be validated", whether or not
+  the metadata was correct — so the warning sat on every image in the project and
+  never went away, not even after applying its own quick fix.
+
+  That message was never a finding. `@valbuild/core` cannot read files, so it
+  cannot answer whether stored dimensions match the image, and it hands the
+  question on as an `image:check-metadata` fix instead. `val validate` has always
+  resolved that by reading the file and comparing; the language server now does
+  the same, and reports only what actually disagrees:
+
+  ```
+  Image width is incorrect! Found: 800. Expected: 944
+  ```
+
+  An image whose metadata is right gets nothing. A missing `width`, `height` or
+  `mimeType` is reported, as is a stale one, with the quick fix still offered. A
+  file that is not on disk is still reported as a missing file rather than as a
+  metadata problem.
+
+  The four messages involved say what they mean now, in the editor and in
+  `val validate` alike:
+
+  - "Image metadata has not been checked against the file." (was "Found image
+    metadata, but it could not be validated. An image must have a width (positive
+    number), a height (positive number) and a mime type." — which described a
+    check that never ran)
+  - "Image metadata is missing: width, height and mimeType." (was "Could not
+    validate Image metadata.")
+  - "File mimeType has not been checked against the file." (was "Found mimeType,
+    but it could not be validated.")
+  - "File metadata is missing: mimeType." (was "Missing File mimeType.")
+
+  Also fixes an `s.file()` whose `mimeType` is missing: it reported "Mime type and
+  file extension not matching. Mime type is 'undefined'" with no fix attached, so
+  no quick fix was offered and the `file:add-metadata` case was unreachable. It
+  now reports the missing mime type and offers to add it.
+
+- [#579](https://github.com/valbuild/val/pull/579) [`b2812ae`](https://github.com/valbuild/val/commit/b2812ae4ee03e005ecead3365f49c625e536f94d) Thanks [@freekh](https://github.com/freekh)! - Every release now ships a changelog. Each package's `CHANGELOG.md` records what
+  changed under the version that shipped it — with a link to the pull request, the
+  commit and the author — and the same entry becomes the body of the GitHub
+  Release for the tag. The file is included in the npm tarball, so it is also
+  readable from an installed copy.
+
+  Up to now those changelogs were generated empty, and the GitHub Releases with
+  them, so there was no record of what any given version contained. Releases from
+  this one on have one; earlier versions stay blank.

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

@@ -31,7 +31,7 @@ import { ModulePath, SourcePath, getValPath, isVal } from "./val/index.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
 import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
-import { getMimeType, mimeTypeToFileExt, filenameToMimeType } from "./mimeType/index.js";
+import { getMimeType, mimeTypeToFileExt, filenameToMimeType, mimeTypeMatchesAccept } from "./mimeType/index.js";
 import { type ImageMetadata } from "./schema/image.js";
 import { type FileMetadata } from "./schema/file.js";
 import { isJson, getJsonImport, resolveJsonValues } from "./source/json.js";
@@ -51,6 +51,7 @@ export { type SerializedImageSchema, ImageSchema } from "./schema/image.js";
 export { type SerializedFileSchema, FileSchema } from "./schema/file.js";
 export { type SerializedDateSchema, DateSchema } from "./schema/date.js";
 export { type SerializedColorSchema, type ColorOptions, ColorSchema, } from "./schema/color.js";
+export { type SerializedCodeSchema, type CodeOptions, type CodeLanguage, CodeSchema, CODE_LANGUAGES, } from "./schema/code.js";
 export { type ColorFormat, type ParsedColor, COLOR_FORMATS, DEFAULT_COLOR_FORMAT, } from "./schema/colorFormat.js";
 export { type SerializedDateTimeSchema, DateTimeSchema, } from "./schema/datetime.js";
 export { type SerializedKeyOfSchema, KeyOfSchema } from "./schema/keyOf.js";
@@ -60,7 +61,7 @@ export { type SerializedUnionSchema, UnionSchema, type SerializedStringUnionSche
 export { type SerializedLiteralSchema, LiteralSchema } from "./schema/literal.js";
 export { deserializeSchema } from "./schema/deserialize.js";
 export { type PreviewItem, type ItemPreviewInput, type RecordPreview, type ArrayPreview, type ReifiedPreview, type PreviewScope, previewScope, } from "./preview.js";
-export { type CodeLanguage, type StringRender, type InlineRender, type FieldRender, CODE_LANGUAGES, isInlineRender, } from "./render.js";
+export { type InlineRender, type FieldRender, isInlineRender } from "./render.js";
 export type { ValRouter, RouteValidationError } from "./router.js";
 export { getSourcePathFromRoute } from "./getSourcePathFromRoute.js";
 export declare const FATAL_ERROR_TYPES: readonly ["no-schema", "no-source", "invalid-id", "no-module", "invalid-patch"];
@@ -113,6 +114,7 @@ declare const Internal: {
     getMimeType: typeof getMimeType;
     mimeTypeToFileExt: typeof mimeTypeToFileExt;
     filenameToMimeType: typeof filenameToMimeType;
+    mimeTypeMatchesAccept: typeof mimeTypeMatchesAccept;
     EXT_TO_MIME_TYPES: Record<string, string>;
     MIME_TYPES_TO_EXT: {
         [k: string]: string;

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

@@ -13,6 +13,7 @@ import { file } from "./schema/file.js";
 import { files } from "./schema/files.js";
 import { date } from "./schema/date.js";
 import { datetime } from "./schema/datetime.js";
+import { code } from "./schema/code.js";
 import { color } from "./schema/color.js";
 import { route } from "./schema/route.js";
 import { router } from "./schema/router.js";
@@ -206,6 +207,23 @@ export type InitSchema = {
      *
      */
     readonly color: typeof color;
+    /**
+     * Define a string edited in a code editor.
+     *
+     * Pass a `language` to syntax highlight it; leave it out for a plain
+     * monospaced editor. The value is a plain string, and — unlike `s.string()` —
+     * it is never stega encoded, so the code reaches your app as it was written.
+     *
+     * @example
+     * const schema = s.code({ language: "typescript" });
+     * export default c.define("/example.val.ts", schema, "const a = 1;");
+     *
+     * @example
+     * const schema = s.code();
+     * export default c.define("/example.val.ts", schema, "no highlighting here");
+     *
+     */
+    readonly code: typeof code;
     /**
      * Define a string that references a route path in your application.
      *
@@ -317,6 +335,7 @@ export declare function initSchema(): {
     date: (options?: Record<string, never>) => import("./index.js").DateSchema<import("./index.js").RawString>;
     datetime: (options?: Record<string, never>) => import("./index.js").DateTimeSchema<import("./index.js").RawString>;
     color: (options?: import("./index.js").ColorOptions) => import("./index.js").ColorSchema<import("./index.js").RawString>;
+    code: (options?: import("./index.js").CodeOptions) => import("./index.js").CodeSchema<import("./index.js").RawString>;
     route: <T extends string>(options?: Record<string, never>) => import("./index.js").RouteSchema<T>;
     router: typeof router;
     images: <Accept extends `image/${string}`>(options: import("./schema/images.js").ImagesOptions<Accept>) => import("./index.js").RecordSchema<import("./index.js").ObjectSchema<{

package/dist/declarations/src/mimeType/convertMimeType.d.ts

@@ -1,3 +1,17 @@
 export declare function getMimeType(base64Url: string): string | undefined;
 export declare function mimeTypeToFileExt(mimeType: string): string;
 export declare function filenameToMimeType(filename: string): string | undefined;
+/**
+ * Whether `mimeType` satisfies an `accept` string.
+ *
+ * `accept` is the HTML file-input syntax: a comma-separated list of exact mime
+ * types (`image/png`), type wildcards (`image` followed by `/` and a star) or
+ * the catch-all star-slash-star.
+ *
+ * This lived in three places - `ImageSchema`, `FileSchema` and the media
+ * branch of `RecordSchema` - which is how the third copy grew a redundant
+ * `image` wildcard case that the general wildcard branch already covered.
+ * Anything that has to decide whether an `accept` is satisfied, validation and
+ * editor tooling alike, should call this.
+ */
+export declare function mimeTypeMatchesAccept(mimeType: string, accept: string): boolean;

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

@@ -1,10 +1,14 @@
 import type { SerializedSchema } from "./schema/index.js";
 /**
  * A RENDER is how the FIELD ITSELF is laid out in the editor, and it applies
- * only when you are looking at the field: `s.string().render({ as: "textarea"
- * })`, `.render({ as: "code", language })`, `.render({ as: "inline" })` on an
+ * only when you are looking at the field: `.render({ as: "inline" })` on an
  * array/record item.
  *
+ * It is deliberately the ONE thing a render can say. What a string looks like
+ * when it holds more than a line is the schema's own business — `.multiline()`
+ * for a text box, `s.code({ language })` for a code editor — not a layout
+ * bolted onto `s.string()` from outside.
+ *
  * A PREVIEW (`preview.ts`) is the other thing: how the VALUE is shown wherever
  * a preview of it is needed — a list row, a reference dropdown, a search hit —
  * that is, wherever the value is navigable to rather than open. The two never
@@ -25,13 +29,6 @@ import type { SerializedSchema } from "./schema/index.js";
  * `render` its own execute/store pair again. It is NOT to re-merge the two:
  * conflating them is what this file was split up to undo.
  */
-/**
- * The list is the declaration and {@link CodeLanguage} is derived from it, so
- * that a validator elsewhere (`shared`'s zod schema) can enumerate the same
- * languages without a second copy that drifts. Same shape as `COLOR_FORMATS`.
- */
-export declare const CODE_LANGUAGES: readonly ["typescript", "javascript", "javascriptreact", "typescriptreact", "json", "java", "html", "css", "xml", "markdown", "sql", "python", "rust", "php", "go", "cpp", "sass", "vue", "angular"];
-export type CodeLanguage = (typeof CODE_LANGUAGES)[number];
 /**
  * `{ as: "inline" }` on a field that is the ITEM of an array or record: the
  * container renders the field itself inside each (sortable) row, instead of a
@@ -49,21 +46,10 @@ export type InlineRender = {
     as: "inline";
 };
 /**
- * What `.render(...)` takes on every field except `s.string()`, and what the
- * serialized schema carries verbatim.
+ * What `.render(...)` takes on every field, and what the serialized schema
+ * carries verbatim.
  */
 export type FieldRender = InlineRender;
-/**
- * What `s.string().render(...)` takes, and what the serialized schema carries
- * verbatim. A string has editor layouts of its own (textarea, code) in
- * addition to the container-facing `inline`.
- */
-export type StringRender = {
-    as: "textarea";
-} | {
-    as: "code";
-    language: CodeLanguage;
-} | InlineRender;
 /**
  * Is this item schema edited INSIDE its list row, rather than behind a
  * clickable preview row that navigates to it?

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

@@ -0,0 +1,85 @@
+import { CustomValidateFunction, Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
+import { ItemPreviewInput, PreviewItem, ReifiedPreview } from "../preview.js";
+import { FieldRender } from "../render.js";
+import { SourcePath } from "../val/index.js";
+import { RawString } from "./string.js";
+import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
+/**
+ * The list is the declaration and {@link CodeLanguage} is derived from it, so
+ * that a validator elsewhere (`shared`'s zod schema) can enumerate the same
+ * languages without a second copy that drifts. Same shape as `COLOR_FORMATS`.
+ */
+export declare const CODE_LANGUAGES: readonly ["typescript", "javascript", "javascriptreact", "typescriptreact", "json", "java", "html", "css", "xml", "markdown", "sql", "python", "rust", "php", "go", "cpp", "sass", "vue", "angular"];
+export type CodeLanguage = (typeof CODE_LANGUAGES)[number];
+export type CodeOptions = {
+    /**
+     * The language to syntax highlight the editor with.
+     *
+     * Omit it for a plain monospaced editor with no highlighting.
+     *
+     * @example
+     * "typescript"
+     * "json"
+     * "markdown"
+     */
+    language?: CodeLanguage;
+};
+export type SerializedCodeSchema = {
+    type: "code";
+    /** 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;
+    options?: CodeOptions;
+    opt: boolean;
+    customValidate?: boolean;
+    readonly?: boolean;
+    hidden?: boolean;
+    description?: string;
+};
+/**
+ * A string edited in a code editor.
+ *
+ * Its own schema type rather than a layout on `s.string()`: the language is
+ * part of what the content IS, not of how one field happens to be drawn, and
+ * being a type is what lets the value stay out of stega encoding — invisible
+ * characters woven into source code are not something a consumer can render.
+ */
+export declare class CodeSchema<Src extends string | null> extends Schema<Src> {
+    private readonly options?;
+    private readonly opt;
+    private readonly customValidateFunctions;
+    private readonly isReadonly;
+    private readonly isHidden;
+    private readonly description?;
+    private readonly renderInput;
+    private readonly previewInput;
+    constructor(options?: CodeOptions | undefined, opt?: boolean, customValidateFunctions?: CustomValidateFunction<Src>[], isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, renderInput?: FieldRender | null, previewInput?: ItemPreviewInput<Src> | null);
+    describe(description: string | null): CodeSchema<Src>;
+    validate(validationFunction: (src: Src) => false | string): CodeSchema<Src>;
+    protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
+    protected executeValidate(path: SourcePath, src: Src): ValidationErrors;
+    protected executeAssert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
+    nullable(): CodeSchema<Src | null>;
+    readonly(): CodeSchema<Src>;
+    hidden(): CodeSchema<Src>;
+    /**
+     * 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): CodeSchema<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`.
+     */
+    preview(select: ItemPreviewInput<Src>): CodeSchema<Src>;
+    protected executePreviewItem(src: NonNullable<Src>): PreviewItem | null;
+    protected declaresItemPreview(): boolean;
+    protected executeSerialize(): SerializedSchema;
+    protected executePreview(): ReifiedPreview;
+}
+export declare const code: (options?: CodeOptions) => CodeSchema<RawString>;

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

@@ -12,6 +12,7 @@ import { SerializedRecordSchema } from "./record.js";
 import { SerializedRichTextSchema } from "./richtext.js";
 import { RawString, SerializedStringSchema } from "./string.js";
 import { SerializedUnionSchema } from "./union.js";
+import { SerializedCodeSchema } from "./code.js";
 import { SerializedColorSchema } from "./color.js";
 import { SerializedDateSchema } from "./date.js";
 import { SerializedDateTimeSchema } from "./datetime.js";
@@ -20,7 +21,7 @@ import { ValidationError, ValidationErrors } from "./validation/ValidationError.
 import { FileSource } from "../source/media.js";
 import { GenericRichTextSourceNode, RichTextSource } from "../source/richtext.js";
 import { ReifiedPreview, PreviewScope, PreviewItem } from "../preview.js";
-export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedDateTimeSchema | SerializedColorSchema | SerializedRouteSchema | SerializedImageSchema;
+export type SerializedSchema = SerializedStringSchema | SerializedLiteralSchema | SerializedBooleanSchema | SerializedNumberSchema | SerializedObjectSchema | SerializedArraySchema | SerializedUnionSchema | SerializedRichTextSchema | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema | SerializedDateSchema | SerializedDateTimeSchema | SerializedColorSchema | SerializedCodeSchema | SerializedRouteSchema | SerializedImageSchema;
 type Primitives = number | string | boolean | null | FileSource;
 export type AssertError = {
     message: string;

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

@@ -1,6 +1,6 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { ItemPreviewInput, PreviewItem, ReifiedPreview } from "../preview.js";
-import { StringRender } from "../render.js";
+import { FieldRender } from "../render.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationError, ValidationErrors } from "./validation/ValidationError.js";
 type StringOptions = {
@@ -20,7 +20,17 @@ export type SerializedStringSchema = {
      * 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;
+    render?: FieldRender;
+    /**
+     * Set by `.multiline()`: the field is a growing text box rather than a
+     * single-line input.
+     *
+     * A property of the schema rather than a `render` variant, because it says
+     * what the string IS — text that may hold line breaks — and not merely how one
+     * field is drawn. It is read the same way a render is, straight off the
+     * serialized schema where the field is drawn.
+     */
+    multiline?: boolean;
     /** Set when this schema declares a `preview`. The closure itself cannot serialize. */
     preview?: true;
     options?: {
@@ -54,7 +64,8 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     private readonly isHidden;
     private readonly description?;
     private readonly previewInput;
-    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: StringRender | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null);
+    private readonly isMultiline;
+    constructor(options?: StringOptions | undefined, opt?: boolean, isRaw?: boolean, customValidateFunctions?: ((src: Src) => false | string)[], renderInput?: FieldRender | null, isReadonly?: boolean, isHidden?: boolean, description?: string | undefined, previewInput?: ItemPreviewInput<Src> | null, isMultiline?: boolean);
     describe(description: string | null): StringSchema<Src>;
     /**
      * @deprecated Use `minLength` instead
@@ -77,13 +88,27 @@ export declare class StringSchema<Src extends string | null> extends Schema<Src>
     protected executeCustomValidateAt(path: SourcePath, src: Src): ValidationError[];
     protected executeSerialize(): SerializedSchema;
     /**
-     * How this field is laid out in the editor: a textarea, or a code editor for
-     * the given language.
+     * This string holds text that may run to several lines: the editor gives it a
+     * growing text box instead of a single-line input.
+     *
+     * Nothing else changes — the value is still a plain string, and no validation
+     * is added or removed. For code, use `s.code({ language })` instead, which is
+     * its own schema type.
+     *
+     * @example
+     * const schema = s.string().multiline();
+     * export default c.define("/example.val.ts", schema, "Line one\nLine two");
+     */
+    multiline(): StringSchema<Src>;
+    /**
+     * 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`. What a CONTAINER
      * shows for its items is a `preview`, which is a different thing entirely.
      */
-    render(input: StringRender): StringSchema<Src>;
+    render(input: FieldRender): StringSchema<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