From a65671b305a347afc47d7b2ec4af14b749c01d59 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Wed, 4 Feb 2026 19:44:08 +0000 Subject: [PATCH 01/32] Add base schema for files and images --- packages/core/src/initSchema.ts | 42 ++ packages/core/src/schema/deserialize.ts | 22 + packages/core/src/schema/files.test.ts | 509 ++++++++++++++++ packages/core/src/schema/files.ts | 449 +++++++++++++++ packages/core/src/schema/images.test.ts | 545 ++++++++++++++++++ packages/core/src/schema/images.ts | 538 +++++++++++++++++ packages/core/src/schema/index.ts | 6 +- .../src/schema/validation/ValidationFix.ts | 2 + 8 files changed, 2112 insertions(+), 1 deletion(-) create mode 100644 packages/core/src/schema/files.test.ts create mode 100644 packages/core/src/schema/files.ts create mode 100644 packages/core/src/schema/images.test.ts create mode 100644 packages/core/src/schema/images.ts diff --git a/packages/core/src/initSchema.ts b/packages/core/src/initSchema.ts index ca2eb98d1..91ebe6a0c 100644 --- a/packages/core/src/initSchema.ts +++ b/packages/core/src/initSchema.ts @@ -11,9 +11,11 @@ import { literal } from "./schema/literal"; import { keyOf } from "./schema/keyOf"; import { record } from "./schema/record"; import { file } from "./schema/file"; +import { files } from "./schema/files"; import { date } from "./schema/date"; import { route } from "./schema/route"; import { router } from "./schema/router"; +import { images } from "./schema/images"; // import { i18n, I18n } from "./schema/future/i18n"; // import { oneOf } from "./schema/future/oneOf"; @@ -200,6 +202,44 @@ export type InitSchema = { * @returns A RecordSchema configured as a router */ readonly router: typeof router; + /** + * Define a collection of images. + * + * @example + * ```typescript + * const schema = s.images({ + * accept: "image/webp", + * directory: "/public/val/images", + * alt: s.string().minLength(4), + * }); + * export default c.define("/content/images.val.ts", schema, { + * "/public/val/images/hero.webp": { + * width: 1920, + * height: 1080, + * mimeType: "image/webp", + * alt: "Hero image", + * }, + * }); + * ``` + */ + readonly images: typeof images; + /** + * Define a collection of files. + * + * @example + * ```typescript + * const schema = s.files({ + * accept: "application/pdf", + * directory: "/public/val/documents", + * }); + * export default c.define("/content/documents.val.ts", schema, { + * "/public/val/documents/report.pdf": { + * mimeType: "application/pdf", + * }, + * }); + * ``` + */ + readonly files: typeof files; }; // export type InitSchemaLocalized = { // readonly i18n: I18n; @@ -220,9 +260,11 @@ export function initSchema() { keyOf, record, file, + files, date, route, router, + images, // i18n: i18n(locales), }; } diff --git a/packages/core/src/schema/deserialize.ts b/packages/core/src/schema/deserialize.ts index 1df84d462..44f1deebc 100644 --- a/packages/core/src/schema/deserialize.ts +++ b/packages/core/src/schema/deserialize.ts @@ -7,7 +7,9 @@ import { ArraySchema } from "./array"; import { BooleanSchema } from "./boolean"; import { DateSchema } from "./date"; import { FileSchema } from "./file"; +import { FilesSchema } from "./files"; import { ImageMetadata, ImageSchema } from "./image"; +import { ImagesSchema } from "./images"; import { KeyOfSchema } from "./keyOf"; import { LiteralSchema } from "./literal"; import { NumberSchema } from "./number"; @@ -134,8 +136,28 @@ export function deserializeSchema( } case "file": return new FileSchema(serialized.options, serialized.opt); + case "files": + return new FilesSchema( + { + accept: serialized.accept, + directory: serialized.directory as "/public" | `/public/${string}`, + }, + serialized.opt, + serialized.remote, + ); case "image": return new ImageSchema(serialized.options, serialized.opt); + case "images": + return new ImagesSchema( + { + accept: serialized.accept as `image/${string}`, + directory: serialized.directory as "/public" | `/public/${string}`, + // Note: alt schema deserialization would need the alt schema to be deserialized + // For now we use the default alt schema + }, + serialized.opt, + serialized.remote, + ); case "date": return new DateSchema(serialized.options); default: { diff --git a/packages/core/src/schema/files.test.ts b/packages/core/src/schema/files.test.ts new file mode 100644 index 000000000..a6a3b541d --- /dev/null +++ b/packages/core/src/schema/files.test.ts @@ -0,0 +1,509 @@ +import { SourcePath } from "../val"; +import { files, FilesEntryMetadata } from "./files"; + +describe("FilesSchema", () => { + describe("assert", () => { + test("should return success if src is a valid files object", () => { + const schema = files({ accept: "application/pdf" }); + const src: Record = { + "/public/val/document.pdf": { + mimeType: "application/pdf", + }, + }; + expect(schema["executeAssert"]("path" as SourcePath, src)).toEqual({ + success: true, + data: src, + }); + }); + + test("should return error if src is null (non-nullable)", () => { + const schema = files({ accept: "application/pdf" }); + const result = schema["executeAssert"]("path" as SourcePath, null); + expect(result.success).toEqual(false); + }); + + test("should return success if src is null (nullable)", () => { + const schema = files({ accept: "application/pdf" }).nullable(); + expect(schema["executeAssert"]("path" as SourcePath, null)).toEqual({ + success: true, + data: null, + }); + }); + + test("should return error if src is not an object", () => { + const schema = files({ accept: "application/pdf" }); + const result = schema["executeAssert"]("path" as SourcePath, "test"); + expect(result.success).toEqual(false); + }); + + test("should return error if src is an array", () => { + const schema = files({ accept: "application/pdf" }); + const result = schema["executeAssert"]("path" as SourcePath, []); + expect(result.success).toEqual(false); + }); + }); + + describe("validate", () => { + test("should validate directory prefix", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }); + const src: Record = { + "/public/val/wrong/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + expect(Object.values(result as object)[0][0].message).toContain( + "must be within the /public/val/documents/ directory", + ); + }); + + test("should accept valid directory prefix", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }); + const src: Record = { + "/public/val/documents/report.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should validate mimeType against accept pattern", () => { + const schema = files({ accept: "application/pdf" }); + const src: Record = { + "/public/val/document.docx": { + mimeType: + "application/vnd.openxmlformats-officedocument.wordprocessingml.document", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + expect(Object.values(result as object)[0][0].message).toContain( + "Mime type mismatch", + ); + }); + + test("should accept wildcard mimeType patterns", () => { + const schema = files({ accept: "application/*" }); + const src: Record = { + "/public/val/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have mime type error + if (result) { + const errors = Object.values(result as object).flat(); + const hasMimeError = errors.some((e: { message: string }) => + e.message.includes("Mime type mismatch"), + ); + expect(hasMimeError).toBe(false); + } + }); + + test("should accept any mimeType with */*", () => { + const schema = files({ accept: "*/*" }); + const src: Record = { + "/public/val/anything.xyz": { + mimeType: "application/octet-stream", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have mime type error + if (result) { + const errors = Object.values(result as object).flat(); + const hasMimeError = errors.some((e: { message: string }) => + e.message.includes("Mime type mismatch"), + ); + expect(hasMimeError).toBe(false); + } + }); + + test("should use default directory /public/val", () => { + const schema = files({ accept: "application/pdf" }); + const src: Record = { + "/public/val/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should accept /public as directory", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public", + }); + const src: Record = { + "/public/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should validate mimeType is a string", () => { + const schema = files({ accept: "application/pdf" }); + const src = { + "/public/val/document.pdf": { + mimeType: 123, + }, + }; + const result = schema["executeValidate"]( + "path" as SourcePath, + src as unknown as Record, + ); + expect(result).toBeTruthy(); + }); + }); + + describe("serialization", () => { + test("should serialize with correct type", () => { + const schema = files({ accept: "application/pdf" }); + const serialized = schema["executeSerialize"](); + expect(serialized.type).toBe("files"); + expect(serialized.accept).toBe("application/pdf"); + expect(serialized.directory).toBe("/public/val"); + expect(serialized.opt).toBe(false); + expect(serialized.remote).toBe(false); + }); + + test("should serialize with custom directory", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/custom", + }); + const serialized = schema["executeSerialize"](); + expect(serialized.directory).toBe("/public/val/custom"); + }); + + test("should serialize remote flag", () => { + const schema = files({ accept: "application/pdf" }).remote(); + const serialized = schema["executeSerialize"](); + expect(serialized.remote).toBe(true); + }); + + test("should serialize nullable flag", () => { + const schema = files({ accept: "application/pdf" }).nullable(); + const serialized = schema["executeSerialize"](); + expect(serialized.opt).toBe(true); + }); + }); + + describe("remote", () => { + test("should create remote variant", () => { + const schema = files({ accept: "application/pdf" }); + const remoteSchema = schema.remote(); + expect(remoteSchema["executeSerialize"]().remote).toBe(true); + }); + + test("should reject remote URLs when remote is not enabled", () => { + const schema = files({ accept: "application/pdf" }); + const src: Record = { + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/document.pdf": + { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasRemoteError = errors.some((e: { message: string }) => + e.message.includes("Remote URLs are not allowed"), + ); + expect(hasRemoteError).toBe(true); + }); + + test("should accept remote URLs when remote is enabled", () => { + const schema = files({ accept: "application/pdf" }).remote(); + const src: Record = { + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/document.pdf": + { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should accept local paths when remote is enabled", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }).remote(); + const src: Record = { + "/public/val/documents/local.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have path errors + if (result) { + const errors = Object.values(result as object).flat(); + const hasPathError = errors.some( + (e: { message: string }) => + e.message.includes("directory") || e.message.includes("Remote"), + ); + expect(hasPathError).toBe(false); + } + }); + + test("should accept mixed remote and local when remote is enabled", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }).remote(); + const src: Record = { + "/public/val/documents/local.pdf": { + mimeType: "application/pdf", + }, + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/documents/remote.pdf": + { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should reject invalid remote URLs", () => { + const schema = files({ accept: "application/pdf" }).remote(); + const src: Record = { + "not-a-valid-url": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasUrlError = errors.some((e: { message: string }) => + e.message.includes("Expected a remote URL"), + ); + expect(hasUrlError).toBe(true); + }); + + test("should reject paths outside directory when remote is enabled but path is not a URL", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }).remote(); + const src: Record = { + "/public/other/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasError = errors.some((e: { message: string }) => + e.message.includes("Expected a remote URL"), + ); + expect(hasError).toBe(true); + }); + + test("should accept http URLs when remote is enabled", () => { + const schema = files({ accept: "application/pdf" }).remote(); + const src: Record = { + "http://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/document.pdf": + { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should reject non-Val remote URLs", () => { + const schema = files({ accept: "application/pdf" }).remote(); + const src: Record = { + "https://example.com/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasInvalidFormatError = errors.some((e: { message: string }) => + e.message.includes("Invalid remote URL format"), + ); + expect(hasInvalidFormatError).toBe(true); + }); + + test("should reject remote URLs with wrong directory in path", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }).remote(); + const src: Record = { + // Remote URL with public/val/other instead of public/val/documents + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/other/document.pdf": + { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasDirectoryError = errors.some((e: { message: string }) => + e.message.includes("not in expected directory"), + ); + expect(hasDirectoryError).toBe(true); + }); + }); + + describe("directory validation", () => { + test("should reject paths with wrong prefix", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val/documents", + }); + const src: Record = { + "/wrong/path/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(true); + }); + + test("should accept paths with exact directory match", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public", + }); + const src: Record = { + "/public/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should accept paths in subdirectories", () => { + const schema = files({ + accept: "application/pdf", + directory: "/public/val", + }); + const src: Record = { + "/public/val/nested/deep/document.pdf": { + mimeType: "application/pdf", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + }); + + describe("custom validation", () => { + test("should support custom validation function", () => { + const schema = files({ accept: "application/pdf" }).validate((src) => { + if (Object.keys(src ?? {}).length === 0) { + return "At least one file is required"; + } + return false; + }); + const src: Record = {}; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasCustomError = errors.some((e: { message: string }) => + e.message.includes("At least one file is required"), + ); + expect(hasCustomError).toBe(true); + }); + }); + + describe("accept patterns", () => { + test("should accept comma-separated mime types", () => { + const schema = files({ accept: "application/pdf, application/msword" }); + const src1: Record = { + "/public/val/document.pdf": { + mimeType: "application/pdf", + }, + }; + const src2: Record = { + "/public/val/document.doc": { + mimeType: "application/msword", + }, + }; + const result1 = schema["executeValidate"]("path" as SourcePath, src1); + const result2 = schema["executeValidate"]("path" as SourcePath, src2); + // Neither should have mime type errors + [result1, result2].forEach((result) => { + if (result) { + const errors = Object.values(result as object).flat(); + const hasMimeError = errors.some((e: { message: string }) => + e.message.includes("Mime type mismatch"), + ); + expect(hasMimeError).toBe(false); + } + }); + }); + + test("should reject mime types not in accept list", () => { + const schema = files({ accept: "application/pdf, application/msword" }); + const src: Record = { + "/public/val/document.txt": { + mimeType: "text/plain", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasMimeError = errors.some((e: { message: string }) => + e.message.includes("Mime type mismatch"), + ); + expect(hasMimeError).toBe(true); + }); + }); +}); diff --git a/packages/core/src/schema/files.ts b/packages/core/src/schema/files.ts new file mode 100644 index 000000000..c7da42761 --- /dev/null +++ b/packages/core/src/schema/files.ts @@ -0,0 +1,449 @@ +import { CustomValidateFunction, Schema, SchemaAssertResult } from "."; +import { ReifiedRender, RenderSelector } from "../render"; +import { splitRemoteRef } from "../remote/splitRemoteRef"; +import { createValPathOfItem } from "../selector/SelectorProxy"; +import { ModuleFilePath, SourcePath } from "../val"; +import { + ValidationError, + ValidationErrors, +} from "./validation/ValidationError"; +import { ImageSource } from "../source/image"; +import { RemoteSource } from "../source/remote"; +import { ImageMetadata } from "./image"; + +/** + * Options for s.files() + */ +export type FilesOptions = { + /** + * The accepted mime type pattern (e.g., "application/pdf", "text/*", "*\/*") + */ + accept: string; + /** + * The directory where files should be stored. + * Must start with "/public" (e.g., "/public/val/files") + * @default "/public/val" + */ + directory?: "/public" | `/public/${string}`; + /** + * Whether remote files are allowed + * @default false + */ + remote?: boolean; +}; + +/** + * Metadata for a file entry in the files record + */ +export type FilesEntryMetadata = { + mimeType: string; +}; + +export type SerializedFilesSchema = { + type: "files"; + accept: string; + directory: string; + opt: boolean; + remote: boolean; + customValidate?: boolean; +}; + +export class FilesSchema< + Src extends Record | null, +> extends Schema { + private readonly directory: "/public" | `/public/${string}`; + + constructor( + private readonly options: FilesOptions, + private readonly opt: boolean = false, + private readonly isRemote: boolean = false, + private readonly customValidateFunctions: CustomValidateFunction[] = [], + ) { + super(); + this.directory = options.directory ?? "/public/val"; + } + + remote(): FilesSchema { + return new FilesSchema( + this.options, + this.opt, + true, + this.customValidateFunctions, + ); + } + + validate(validationFunction: CustomValidateFunction): FilesSchema { + return new FilesSchema(this.options, this.opt, this.isRemote, [ + ...this.customValidateFunctions, + validationFunction, + ]); + } + + protected executeValidate(path: SourcePath, src: Src): ValidationErrors { + let error: ValidationErrors = false; + const customValidationErrors: ValidationError[] = + this.executeCustomValidateFunctions(src, this.customValidateFunctions, { + path, + }); + + if (this.opt && (src === null || src === undefined)) { + return customValidationErrors.length > 0 + ? { [path]: customValidationErrors } + : false; + } + + if (src === null || src === undefined) { + return { + [path]: [ + ...customValidationErrors, + { message: `Non-optional files was null or undefined.`, value: src }, + ], + } as ValidationErrors; + } + + if (typeof src !== "object") { + return { + [path]: [ + ...customValidationErrors, + { message: `Expected 'object', got '${typeof src}'`, value: src }, + ], + } as ValidationErrors; + } + + if (Array.isArray(src)) { + return { + [path]: [ + ...customValidationErrors, + { message: `Expected 'object', got 'array'`, value: src }, + ], + } as ValidationErrors; + } + + for (const customValidationError of customValidationErrors) { + error = this.appendValidationError( + error, + path, + customValidationError.message, + src, + customValidationError.schemaError, + ); + } + + // Validate each entry + for (const [key, entry] of Object.entries(src)) { + const subPath = createValPathOfItem(path, key); + if (!subPath) { + error = this.appendValidationError( + error, + path, + `Internal error: could not create path at ${path} for key ${key}`, + src, + ); + continue; + } + + // Validate key is either a valid local path or remote URL + const keyError = this.validateKey(subPath, key); + if (keyError) { + if (error) { + error = { ...error, ...keyError }; + } else { + error = keyError; + } + } + + // Validate entry metadata + const entryError = this.validateEntry( + subPath, + entry as FilesEntryMetadata, + ); + if (entryError) { + if (error) { + error = { ...error, ...entryError }; + } else { + error = entryError; + } + } + } + + return error; + } + + private isRemoteUrl(url: string): boolean { + return url.startsWith("https://") || url.startsWith("http://"); + } + + private validateKey(path: SourcePath, key: string): ValidationErrors { + const isRemoteUrl = this.isRemoteUrl(key); + const isLocalPath = key.startsWith(this.directory); + + if (this.isRemote) { + // When remote is enabled, accept either remote URLs or local paths + if (isRemoteUrl) { + // Validate remote URL format using splitRemoteRef + const remoteResult = splitRemoteRef(key); + if (remoteResult.status === "error") { + return { + [path]: [ + { + message: `Invalid remote URL format. Use Val tooling (CLI, VS Code extension, or Val Studio) to upload files. Got: ${key}`, + value: key, + fixes: ["files:check-remote"], + }, + ], + }; + } + // Check that the file path in the remote URL matches our directory constraint + const remotePath = "/" + remoteResult.filePath; + if (!remotePath.startsWith(this.directory)) { + return { + [path]: [ + { + message: `Remote file path '${remotePath}' is not in expected directory '${this.directory}'. Use Val tooling to upload files to the correct directory.`, + value: key, + fixes: ["files:check-remote"], + }, + ], + }; + } + return false; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `Expected a remote URL (https://...) or a local path starting with ${this.directory}/. Got: ${key}`, + value: key, + }, + ], + }; + } + } else { + // When remote is disabled, only accept local paths + if (isRemoteUrl) { + return { + [path]: [ + { + message: `Remote URLs are not allowed. Use .remote() to enable remote files. Got: ${key}`, + value: key, + fixes: ["files:check-remote"], + }, + ], + }; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `File path must be within the ${this.directory}/ directory. Got: ${key}`, + value: key, + }, + ], + }; + } + } + + return false; + } + + private validateEntry( + path: SourcePath, + entry: FilesEntryMetadata, + ): ValidationErrors { + if (typeof entry !== "object" || entry === null) { + return { + [path]: [ + { message: `Expected 'object', got '${typeof entry}'`, value: entry }, + ], + }; + } + + const errors: ValidationError[] = []; + + // Validate mimeType + if (typeof entry.mimeType !== "string") { + errors.push({ + message: `Expected 'mimeType' to be a string, got '${typeof entry.mimeType}'`, + value: entry, + }); + } else { + // Validate against accept pattern + const mimeTypeError = this.validateMimeType(entry.mimeType); + if (mimeTypeError) { + errors.push({ message: mimeTypeError, value: entry }); + } + } + + if (errors.length > 0) { + return { [path]: errors }; + } + + return false; + } + + private validateMimeType(mimeType: string): string | null { + const { accept } = this.options; + + if (!mimeType.includes("/")) { + return `Invalid mime type format. Got: '${mimeType}'`; + } + + const acceptedTypes = accept.split(",").map((type) => type.trim()); + + const isValidMimeType = acceptedTypes.some((acceptedType) => { + if (acceptedType === "*/*") { + return true; + } + if (acceptedType.endsWith("/*")) { + const baseType = acceptedType.slice(0, -2); + return mimeType.startsWith(baseType); + } + return acceptedType === mimeType; + }); + + if (!isValidMimeType) { + return `Mime type mismatch. Found '${mimeType}' but schema accepts '${accept}'`; + } + + return null; + } + + protected executeAssert( + path: SourcePath, + src: unknown, + ): SchemaAssertResult { + if (this.opt && src === null) { + return { + success: true, + data: src, + } as SchemaAssertResult; + } + + if (src === null) { + return { + success: false, + errors: { + [path]: [ + { message: `Expected 'object', got 'null'`, typeError: true }, + ], + }, + }; + } + + if (typeof src !== "object") { + return { + success: false, + errors: { + [path]: [ + { + message: `Expected 'object', got '${typeof src}'`, + typeError: true, + }, + ], + }, + }; + } + + if (Array.isArray(src)) { + return { + success: false, + errors: { + [path]: [ + { message: `Expected 'object', got 'array'`, typeError: true }, + ], + }, + }; + } + + return { + success: true, + data: src, + } as SchemaAssertResult; + } + + nullable(): FilesSchema { + return new FilesSchema( + this.options, + true, + this.isRemote, + this.customValidateFunctions as CustomValidateFunction[], + ); + } + + protected executeSerialize(): SerializedFilesSchema { + return { + type: "files", + accept: this.options.accept, + directory: this.directory, + opt: this.opt, + remote: this.isRemote, + customValidate: + this.customValidateFunctions && + this.customValidateFunctions?.length > 0, + }; + } + + private renderInput: { + layout: "list"; + select: (input: { + key: string; + val: RenderSelector>; + }) => { + title: string; + subtitle?: string | null; + image?: ImageSource | RemoteSource | null; + }; + } | null = null; + + protected executeRender( + sourcePath: SourcePath | ModuleFilePath, + src: Src, + ): ReifiedRender { + const res: ReifiedRender = {}; + if (src === null) { + return res; + } + // Files don't have nested render logic, so we just return empty + return res; + } + + render(input: { + as: "list"; + select: (input: { + key: string; + val: RenderSelector>; + }) => { + title: string; + subtitle?: string | null; + image?: ImageSource | RemoteSource | null; + }; + }) { + this.renderInput = { + layout: input.as, + select: input.select, + }; + return this; + } +} + +/** + * Define a collection of files. + * + * @example + * ```typescript + * const schema = s.files({ + * accept: "application/pdf", + * directory: "/public/val/documents", + * }); + * export default c.define("/content/documents.val.ts", schema, { + * "/public/val/documents/report.pdf": { + * mimeType: "application/pdf", + * }, + * }); + * ``` + */ +export const files = ( + options: FilesOptions, +): FilesSchema> => { + return new FilesSchema(options); +}; diff --git a/packages/core/src/schema/images.test.ts b/packages/core/src/schema/images.test.ts new file mode 100644 index 000000000..2b4328e3c --- /dev/null +++ b/packages/core/src/schema/images.test.ts @@ -0,0 +1,545 @@ +import { SourcePath } from "../val"; +import { images, ImagesEntryMetadata } from "./images"; +import { string } from "./string"; +import { record } from "./record"; + +describe("ImagesSchema", () => { + describe("assert", () => { + test("should return success if src is a valid images object", () => { + const schema = images({ accept: "image/webp" }); + const src: Record = { + "/public/val/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Test image", + }, + }; + expect(schema["executeAssert"]("path" as SourcePath, src)).toEqual({ + success: true, + data: src, + }); + }); + + test("should return error if src is null (non-nullable)", () => { + const schema = images({ accept: "image/webp" }); + const result = schema["executeAssert"]("path" as SourcePath, null); + expect(result.success).toEqual(false); + }); + + test("should return success if src is null (nullable)", () => { + const schema = images({ accept: "image/webp" }).nullable(); + expect(schema["executeAssert"]("path" as SourcePath, null)).toEqual({ + success: true, + data: null, + }); + }); + + test("should return error if src is not an object", () => { + const schema = images({ accept: "image/webp" }); + const result = schema["executeAssert"]("path" as SourcePath, "test"); + expect(result.success).toEqual(false); + }); + + test("should return error if src is an array", () => { + const schema = images({ accept: "image/webp" }); + const result = schema["executeAssert"]("path" as SourcePath, []); + expect(result.success).toEqual(false); + }); + }); + + describe("validate", () => { + test("should validate directory prefix", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }); + const src: Record = { + "/public/val/wrong/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Test image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + expect(Object.values(result as object)[0][0].message).toContain( + "must be within the /public/val/images/ directory", + ); + }); + + test("should accept valid directory prefix", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }); + const src: Record = { + "/public/val/images/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Test image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error since path is valid + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should validate mimeType against accept pattern", () => { + const schema = images({ accept: "image/webp" }); + const src: Record = { + "/public/val/test.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "Test image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + expect(Object.values(result as object)[0][0].message).toContain( + "Mime type mismatch", + ); + }); + + test("should accept wildcard mimeType patterns", () => { + const schema = images({ accept: "image/*" }); + const src: Record = { + "/public/val/test.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "Test image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have mime type error (but may have metadata check error) + if (result) { + const errors = Object.values(result as object).flat(); + const hasMimeError = errors.some((e: { message: string }) => + e.message.includes("Mime type mismatch"), + ); + expect(hasMimeError).toBe(false); + } + }); + + test("should validate required width and height", () => { + const schema = images({ accept: "image/webp" }); + const src = { + "/public/val/test.webp": { + mimeType: "image/webp", + alt: "Test image", + }, + }; + const result = schema["executeValidate"]( + "path" as SourcePath, + src as unknown as Record, + ); + expect(result).toBeTruthy(); + }); + + test("should validate alt with custom alt schema", () => { + const schema = images({ + accept: "image/webp", + alt: string().minLength(10), + }); + const src: Record = { + "/public/val/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Short", // Less than 10 chars + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + }); + + test("should allow null alt when using nullable alt schema", () => { + const schema = images({ + accept: "image/webp", + alt: string().nullable(), + }); + const src: Record = { + "/public/val/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: null, + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have alt-related errors + if (result) { + const errors = Object.values(result as object).flat(); + const hasAltError = errors.some( + (e: { message: string }) => + e.message.includes("alt") || e.message.includes("string"), + ); + expect(hasAltError).toBe(false); + } + }); + + test("should use default directory /public/val", () => { + const schema = images({ accept: "image/webp" }); + const src: Record = { + "/public/val/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Test", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should validate hotspot if present", () => { + const schema = images({ accept: "image/webp" }); + const src = { + "/public/val/test.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Test", + hotspot: { x: "invalid", y: 0.5 }, + }, + }; + const result = schema["executeValidate"]( + "path" as SourcePath, + src as unknown as Record, + ); + expect(result).toBeTruthy(); + }); + }); + + describe("serialization", () => { + test("should serialize with correct type", () => { + const schema = images({ accept: "image/webp" }); + const serialized = schema["executeSerialize"](); + expect(serialized.type).toBe("images"); + expect(serialized.accept).toBe("image/webp"); + expect(serialized.directory).toBe("/public/val"); + expect(serialized.opt).toBe(false); + expect(serialized.remote).toBe(false); + }); + + test("should serialize with custom directory", () => { + const schema = images({ + accept: "image/png", + directory: "/public/val/custom", + }); + const serialized = schema["executeSerialize"](); + expect(serialized.directory).toBe("/public/val/custom"); + }); + + test("should serialize remote flag", () => { + const schema = images({ accept: "image/webp" }).remote(); + const serialized = schema["executeSerialize"](); + expect(serialized.remote).toBe(true); + }); + + test("should serialize nullable flag", () => { + const schema = images({ accept: "image/webp" }).nullable(); + const serialized = schema["executeSerialize"](); + expect(serialized.opt).toBe(true); + }); + }); + + describe("remote", () => { + test("should create remote variant", () => { + const schema = images({ accept: "image/webp" }); + const remoteSchema = schema.remote(); + expect(remoteSchema["executeSerialize"]().remote).toBe(true); + }); + + test("should reject remote URLs when remote is not enabled", () => { + const schema = images({ accept: "image/webp" }); + const src: Record = { + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/image.webp": + { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Remote image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasRemoteError = errors.some((e: { message: string }) => + e.message.includes("Remote URLs are not allowed"), + ); + expect(hasRemoteError).toBe(true); + }); + + test("should accept remote URLs when remote is enabled", () => { + const schema = images({ accept: "image/webp" }).remote(); + const src: Record = { + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/image.webp": + { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Remote image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should accept local paths when remote is enabled", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }).remote(); + const src: Record = { + "/public/val/images/local.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Local image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have path errors + if (result) { + const errors = Object.values(result as object).flat(); + const hasPathError = errors.some( + (e: { message: string }) => + e.message.includes("directory") || e.message.includes("Remote"), + ); + expect(hasPathError).toBe(false); + } + }); + + test("should accept mixed remote and local when remote is enabled", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }).remote(); + const src: Record = { + "/public/val/images/local.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Local image", + }, + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/images/remote.webp": + { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Remote image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should reject invalid remote URLs", () => { + const schema = images({ accept: "image/webp" }).remote(); + const src: Record = { + "not-a-valid-url": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Invalid URL", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasUrlError = errors.some((e: { message: string }) => + e.message.includes("Expected a remote URL"), + ); + expect(hasUrlError).toBe(true); + }); + + test("should reject paths outside directory when remote is enabled but path is not a URL", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }).remote(); + const src: Record = { + "/public/other/image.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Wrong directory", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasError = errors.some((e: { message: string }) => + e.message.includes("Expected a remote URL"), + ); + expect(hasError).toBe(true); + }); + + test("should accept http URLs when remote is enabled", () => { + const schema = images({ accept: "image/webp" }).remote(); + const src: Record = { + "http://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/image.webp": + { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "HTTP image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeFalsy(); + }); + + test("should reject non-Val remote URLs", () => { + const schema = images({ accept: "image/webp" }).remote(); + const src: Record = { + "https://example.com/image.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "External image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasInvalidFormatError = errors.some((e: { message: string }) => + e.message.includes("Invalid remote URL format"), + ); + expect(hasInvalidFormatError).toBe(true); + }); + + test("should reject remote URLs with wrong directory in path", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }).remote(); + const src: Record = { + // Remote URL with public/val/other instead of public/val/images + "https://remote.val.build/file/p/proj123/b/01/v/1.0.0/h/abc123/f/def456/p/public/val/other/image.webp": + { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Wrong directory in remote", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasDirectoryError = errors.some((e: { message: string }) => + e.message.includes("not in expected directory"), + ); + expect(hasDirectoryError).toBe(true); + }); + }); + + describe("directory validation", () => { + test("should reject paths with wrong prefix", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val/images", + }); + const src: Record = { + "/wrong/path/image.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Wrong path", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(true); + }); + + test("should accept paths with exact directory match", () => { + const schema = images({ + accept: "image/webp", + directory: "/public", + }); + const src: Record = { + "/public/image.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Public root image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + + test("should accept paths in subdirectories", () => { + const schema = images({ + accept: "image/webp", + directory: "/public/val", + }); + const src: Record = { + "/public/val/nested/deep/image.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "Nested image", + }, + }; + const result = schema["executeValidate"]("path" as SourcePath, src); + // Should not have directory error + if (result) { + const errors = Object.values(result as object).flat(); + const hasDirError = errors.some((e: { message: string }) => + e.message.includes("directory"), + ); + expect(hasDirError).toBe(false); + } + }); + }); + + describe("custom validation", () => { + test("should support custom validation function", () => { + const schema = images({ accept: "image/webp" }).validate((src) => { + if (Object.keys(src ?? {}).length === 0) { + return "At least one image is required"; + } + return false; + }); + const src: Record = {}; + const result = schema["executeValidate"]("path" as SourcePath, src); + expect(result).toBeTruthy(); + const errors = Object.values(result as object).flat(); + const hasCustomError = errors.some((e: { message: string }) => + e.message.includes("At least one image is required"), + ); + expect(hasCustomError).toBe(true); + }); + }); +}); diff --git a/packages/core/src/schema/images.ts b/packages/core/src/schema/images.ts new file mode 100644 index 000000000..29513f9b2 --- /dev/null +++ b/packages/core/src/schema/images.ts @@ -0,0 +1,538 @@ +import { + CustomValidateFunction, + Schema, + SchemaAssertResult, + SerializedSchema, +} from "."; +import { ReifiedRender, RenderSelector } from "../render"; +import { splitRemoteRef } from "../remote/splitRemoteRef"; +import { SelectorSource } from "../selector"; +import { createValPathOfItem } from "../selector/SelectorProxy"; +import { ModuleFilePath, SourcePath } from "../val"; +import { + ValidationError, + ValidationErrors, +} from "./validation/ValidationError"; +import { StringSchema, string } from "./string"; +import { RecordSchema } from "./record"; +import { ImageSource } from "../source/image"; +import { RemoteSource } from "../source/remote"; +import { ImageMetadata } from "./image"; + +/** + * Alt schema type - can be a string, nullable string, or a record of locale to string + */ +export type AltSchema = + | StringSchema + | StringSchema + | RecordSchema, Schema, Record>; + +/** + * Options for s.images() + */ +export type ImagesOptions = { + /** + * The accepted mime type pattern. Must be an image type (e.g., "image/png", "image/webp", "image/*") + */ + accept: Accept; + /** + * The directory where images should be stored. + * Must start with "/public" (e.g., "/public/val/images") + * @default "/public/val" + */ + directory?: "/public" | `/public/${string}`; + /** + * Alt text schema. Can be: + * - s.string() for required alt text + * - s.string().nullable() for optional alt text (default) + * - s.record(s.string(), s.string()) for locale-based alt text + */ + alt?: AltSchema; + /** + * Whether remote images are allowed + * @default false + */ + remote?: boolean; +}; + +/** + * Metadata for an image entry in the images record + */ +export type ImagesEntryMetadata = { + width: number; + height: number; + mimeType: string; + alt: string | null; + hotspot?: { + x: number; + y: number; + }; +}; + +export type SerializedImagesSchema = { + type: "images"; + accept: string; + directory: string; + alt: SerializedSchema; + opt: boolean; + remote: boolean; + customValidate?: boolean; +}; + +export class ImagesSchema< + Accept extends `image/${string}`, + Src extends Record | null, +> extends Schema { + private readonly directory: "/public" | `/public/${string}`; + private readonly altSchema: AltSchema; + + constructor( + private readonly options: ImagesOptions, + private readonly opt: boolean = false, + private readonly isRemote: boolean = false, + private readonly customValidateFunctions: CustomValidateFunction[] = [], + ) { + super(); + this.directory = options.directory ?? "/public/val"; + this.altSchema = options.alt ?? string().nullable(); + } + + remote(): ImagesSchema { + return new ImagesSchema( + this.options, + this.opt, + true, + this.customValidateFunctions, + ); + } + + validate( + validationFunction: CustomValidateFunction, + ): ImagesSchema { + return new ImagesSchema(this.options, this.opt, this.isRemote, [ + ...this.customValidateFunctions, + validationFunction, + ]); + } + + protected executeValidate(path: SourcePath, src: Src): ValidationErrors { + let error: ValidationErrors = false; + const customValidationErrors: ValidationError[] = + this.executeCustomValidateFunctions(src, this.customValidateFunctions, { + path, + }); + + if (this.opt && (src === null || src === undefined)) { + return customValidationErrors.length > 0 + ? { [path]: customValidationErrors } + : false; + } + + if (src === null || src === undefined) { + return { + [path]: [ + ...customValidationErrors, + { message: `Non-optional images was null or undefined.`, value: src }, + ], + } as ValidationErrors; + } + + if (typeof src !== "object") { + return { + [path]: [ + ...customValidationErrors, + { message: `Expected 'object', got '${typeof src}'`, value: src }, + ], + } as ValidationErrors; + } + + if (Array.isArray(src)) { + return { + [path]: [ + ...customValidationErrors, + { message: `Expected 'object', got 'array'`, value: src }, + ], + } as ValidationErrors; + } + + for (const customValidationError of customValidationErrors) { + error = this.appendValidationError( + error, + path, + customValidationError.message, + src, + customValidationError.schemaError, + ); + } + + // Validate each entry + for (const [key, entry] of Object.entries(src)) { + const subPath = createValPathOfItem(path, key); + if (!subPath) { + error = this.appendValidationError( + error, + path, + `Internal error: could not create path at ${path} for key ${key}`, + src, + ); + continue; + } + + // Validate key is either a valid local path or remote URL + const keyError = this.validateKey(subPath, key); + if (keyError) { + if (error) { + error = { ...error, ...keyError }; + } else { + error = keyError; + } + } + + // Validate entry metadata + const entryError = this.validateEntry( + subPath, + entry as ImagesEntryMetadata, + ); + if (entryError) { + if (error) { + error = { ...error, ...entryError }; + } else { + error = entryError; + } + } + } + + return error; + } + + private isRemoteUrl(url: string): boolean { + return url.startsWith("https://") || url.startsWith("http://"); + } + + private validateKey(path: SourcePath, key: string): ValidationErrors { + const isRemoteUrl = this.isRemoteUrl(key); + const isLocalPath = key.startsWith(this.directory); + + if (this.isRemote) { + // When remote is enabled, accept either remote URLs or local paths + if (isRemoteUrl) { + // Validate remote URL format using splitRemoteRef + const remoteResult = splitRemoteRef(key); + if (remoteResult.status === "error") { + return { + [path]: [ + { + message: `Invalid remote URL format. Use Val tooling (CLI, VS Code extension, or Val Studio) to upload images. Got: ${key}`, + value: key, + fixes: ["images:check-remote"], + }, + ], + }; + } + // Check that the file path in the remote URL matches our directory constraint + const remotePath = "/" + remoteResult.filePath; + if (!remotePath.startsWith(this.directory)) { + return { + [path]: [ + { + message: `Remote file path '${remotePath}' is not in expected directory '${this.directory}'. Use Val tooling to upload images to the correct directory.`, + value: key, + fixes: ["images:check-remote"], + }, + ], + }; + } + return false; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `Expected a remote URL (https://...) or a local path starting with ${this.directory}/. Got: ${key}`, + value: key, + }, + ], + }; + } + } else { + // When remote is disabled, only accept local paths + if (isRemoteUrl) { + return { + [path]: [ + { + message: `Remote URLs are not allowed. Use .remote() to enable remote images. Got: ${key}`, + value: key, + fixes: ["images:check-remote"], + }, + ], + }; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `File path must be within the ${this.directory}/ directory. Got: ${key}`, + value: key, + }, + ], + }; + } + } + + return false; + } + + private validateEntry( + path: SourcePath, + entry: ImagesEntryMetadata, + ): ValidationErrors { + if (typeof entry !== "object" || entry === null) { + return { + [path]: [ + { message: `Expected 'object', got '${typeof entry}'`, value: entry }, + ], + }; + } + + const errors: ValidationError[] = []; + + // Validate width + if (typeof entry.width !== "number" || entry.width <= 0) { + errors.push({ + message: `Expected 'width' to be a positive number, got '${entry.width}'`, + value: entry, + }); + } + + // Validate height + if (typeof entry.height !== "number" || entry.height <= 0) { + errors.push({ + message: `Expected 'height' to be a positive number, got '${entry.height}'`, + value: entry, + }); + } + + // Validate mimeType + if (typeof entry.mimeType !== "string") { + errors.push({ + message: `Expected 'mimeType' to be a string, got '${typeof entry.mimeType}'`, + value: entry, + }); + } else { + // Validate against accept pattern + const mimeTypeError = this.validateMimeType(entry.mimeType); + if (mimeTypeError) { + errors.push({ message: mimeTypeError, value: entry }); + } + } + + // Validate hotspot if present + if (entry.hotspot !== undefined) { + if ( + typeof entry.hotspot !== "object" || + typeof entry.hotspot.x !== "number" || + typeof entry.hotspot.y !== "number" + ) { + errors.push({ + message: `Hotspot must be an object with x and y as numbers.`, + value: entry, + }); + } + } + + // Validate alt using the alt schema + const altPath = createValPathOfItem(path, "alt"); + if (altPath) { + // Cast to Schema to access protected method + const altSchemaAsSchema = this + .altSchema as unknown as Schema; + const altError = altSchemaAsSchema["executeValidate"]( + altPath, + entry.alt as SelectorSource, + ); + if (altError) { + return altError; + } + } + + if (errors.length > 0) { + return { [path]: errors }; + } + + return false; + } + + private validateMimeType(mimeType: string): string | null { + const { accept } = this.options; + + if (!mimeType.includes("/")) { + return `Invalid mime type format. Got: '${mimeType}'`; + } + + const acceptedTypes = accept.split(",").map((type) => type.trim()); + + const isValidMimeType = acceptedTypes.some((acceptedType) => { + if (acceptedType === "image/*") { + return mimeType.startsWith("image/"); + } + if (acceptedType.endsWith("/*")) { + const baseType = acceptedType.slice(0, -2); + return mimeType.startsWith(baseType); + } + return acceptedType === mimeType; + }); + + if (!isValidMimeType) { + return `Mime type mismatch. Found '${mimeType}' but schema accepts '${accept}'`; + } + + return null; + } + + protected executeAssert( + path: SourcePath, + src: unknown, + ): SchemaAssertResult { + if (this.opt && src === null) { + return { + success: true, + data: src, + } as SchemaAssertResult; + } + + if (src === null) { + return { + success: false, + errors: { + [path]: [ + { message: `Expected 'object', got 'null'`, typeError: true }, + ], + }, + }; + } + + if (typeof src !== "object") { + return { + success: false, + errors: { + [path]: [ + { + message: `Expected 'object', got '${typeof src}'`, + typeError: true, + }, + ], + }, + }; + } + + if (Array.isArray(src)) { + return { + success: false, + errors: { + [path]: [ + { message: `Expected 'object', got 'array'`, typeError: true }, + ], + }, + }; + } + + return { + success: true, + data: src, + } as SchemaAssertResult; + } + + nullable(): ImagesSchema { + return new ImagesSchema( + this.options, + true, + this.isRemote, + this.customValidateFunctions as CustomValidateFunction[], + ); + } + + protected executeSerialize(): SerializedImagesSchema { + // Cast to Schema to access protected method + const altSchemaAsSchema = this + .altSchema as unknown as Schema; + return { + type: "images", + accept: this.options.accept, + directory: this.directory, + alt: altSchemaAsSchema["executeSerialize"](), + opt: this.opt, + remote: this.isRemote, + customValidate: + this.customValidateFunctions && + this.customValidateFunctions?.length > 0, + }; + } + + private renderInput: { + layout: "list"; + select: (input: { + key: string; + val: RenderSelector>; + }) => { + title: string; + subtitle?: string | null; + image?: ImageSource | RemoteSource | null; + }; + } | null = null; + + protected executeRender( + sourcePath: SourcePath | ModuleFilePath, + src: Src, + ): ReifiedRender { + const res: ReifiedRender = {}; + if (src === null) { + return res; + } + // Images don't have nested render logic, so we just return empty + return res; + } + + render(input: { + as: "list"; + select: (input: { + key: string; + val: RenderSelector>; + }) => { + title: string; + subtitle?: string | null; + image?: ImageSource | RemoteSource | null; + }; + }) { + this.renderInput = { + layout: input.as, + select: input.select, + }; + return this; + } +} + +/** + * Define a collection of images. + * + * @example + * ```typescript + * const schema = s.images({ + * accept: "image/webp", + * directory: "/public/val/images", + * alt: s.string().minLength(4), + * }); + * export default c.define("/content/images.val.ts", schema, { + * "/public/val/images/hero.webp": { + * width: 1920, + * height: 1080, + * mimeType: "image/webp", + * alt: "Hero image", + * }, + * }); + * ``` + */ +export const images = ( + options: ImagesOptions, +): ImagesSchema> => { + return new ImagesSchema(options); +}; diff --git a/packages/core/src/schema/index.ts b/packages/core/src/schema/index.ts index 4443d7a72..cb07c6d67 100644 --- a/packages/core/src/schema/index.ts +++ b/packages/core/src/schema/index.ts @@ -4,7 +4,9 @@ import { ModuleFilePath, SourcePath } from "../val"; import { SerializedArraySchema } from "./array"; import { SerializedBooleanSchema } from "./boolean"; import { SerializedFileSchema } from "./file"; +import { SerializedFilesSchema } from "./files"; import { SerializedImageSchema } from "./image"; +import { SerializedImagesSchema } from "./images"; import { SerializedKeyOfSchema } from "./keyOf"; import { SerializedLiteralSchema } from "./literal"; import { SerializedNumberSchema } from "./number"; @@ -39,9 +41,11 @@ export type SerializedSchema = | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema + | SerializedFilesSchema | SerializedDateSchema | SerializedRouteSchema - | SerializedImageSchema; + | SerializedImageSchema + | SerializedImagesSchema; type Primitives = number | string | boolean | null | FileSource; export type AssertError = diff --git a/packages/core/src/schema/validation/ValidationFix.ts b/packages/core/src/schema/validation/ValidationFix.ts index 8040b1948..2aeff31e1 100644 --- a/packages/core/src/schema/validation/ValidationFix.ts +++ b/packages/core/src/schema/validation/ValidationFix.ts @@ -4,11 +4,13 @@ export const ValidationFix = [ "image:upload-remote", "image:download-remote", "image:check-remote", + "images:check-remote", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", + "files:check-remote", "keyof:check-keys", "router:check-route", ] as const; From 3aaa97da65237f4887200d45cdd76cfc3f76f028 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Wed, 4 Feb 2026 19:44:30 +0000 Subject: [PATCH 02/32] Add file gallery component --- packages/ui/public/sample-image-1.jpg | Bin 0 -> 69095 bytes packages/ui/public/sample-image-2.jpg | Bin 0 -> 23498 bytes packages/ui/public/sample-image-3.jpg | Bin 0 -> 126577 bytes packages/ui/public/sample-video.mp4 | Bin 0 -> 788493 bytes .../components/FileGallery/FileGallery.tsx | 82 ++++++++++ .../FileGallery/FileGalleryItem.tsx | 57 +++++++ .../components/FileGallery/FilePreview.tsx | 80 +++++++++ .../FileGallery/FilePreviewModal.tsx | 83 ++++++++++ .../components/FileGallery/FileProperties.tsx | 112 +++++++++++++ .../ui/spa/components/FileGallery/index.ts | 6 + .../stories/FileGallery.stories.tsx | 153 ++++++++++++++++++ .../ui/spa/components/FileGallery/types.ts | 18 +++ 12 files changed, 591 insertions(+) create mode 100644 packages/ui/public/sample-image-1.jpg create mode 100644 packages/ui/public/sample-image-2.jpg create mode 100644 packages/ui/public/sample-image-3.jpg create mode 100644 packages/ui/public/sample-video.mp4 create mode 100644 packages/ui/spa/components/FileGallery/FileGallery.tsx create mode 100644 packages/ui/spa/components/FileGallery/FileGalleryItem.tsx create mode 100644 packages/ui/spa/components/FileGallery/FilePreview.tsx create mode 100644 packages/ui/spa/components/FileGallery/FilePreviewModal.tsx create mode 100644 packages/ui/spa/components/FileGallery/FileProperties.tsx create mode 100644 packages/ui/spa/components/FileGallery/index.ts create mode 100644 packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx create mode 100644 packages/ui/spa/components/FileGallery/types.ts diff --git a/packages/ui/public/sample-image-1.jpg b/packages/ui/public/sample-image-1.jpg new file mode 100644 index 0000000000000000000000000000000000000000..f73cf9027648a54fd5ca3ec271ea2fa578ed3c7b GIT binary patch literal 69095 zcmb5VcU)6T&_9fNZ73?eN2#HTbO<0y3%&Pxr6n{G2uP?`kxmjrZvi3nDug0PvCsk} z5PASXBtU3-fq;U5Z|?JZ-uL(SJNcY*CcB$CIkU5~JNupUXYS7m!;)^ek2eE@fq?|W zH3kNTD-0|bE-_r7bN?MY7cT$L)t1il{x9!J=f(cF%|$xTdh!3Z_euQgf7;Up{txNX z&;QB!f3H^=7+zmx_={fhKu-3-1@!;nFVH03@0q|Na7<9$RS}7|^fgJ{}>V0rw1aK=)+jl>RI*Xfs^9a^>ok z%h#@6y?XunHO8B4OgC@bxXI1JdYg@(=PrPshmY@`@O|JtK`9|VJ~3r+sRyzO3JQ0D zsv0VC>i6XpTR%Tw=cP zr;mY`{va3rqyKq^|4tV#{YBUFm8g7y=5(Rptv_xz4Jr)bU^!g_NjvQ#EEb5sCfRmbw|vgT7;_ePk5_S zP(@imi9|?-@ejp>dg8CB{*^<(?JAsx(`rNMVaSIk5jkmiTjkMWu76e{;^r00x^i}w zau}m;tLpoF3@Y<$MkalT5E``!6^&EOsU6kz;>n0WC-40l;#|Aur~cOKVB*0*uim26 z;bgy&knwfn5D&~KUgIXmu`bgh`4dyZL+{&KNdd%`T=at+iMXp44bTbv9sSv%K;^O_A zGzQJ-Ny6xlM_nra#=t^)@>`5OGul?D!=ZFjRKN%P+Io@okwZlGKM2-UrYl;{szJ9K>?}*! z5KQbIz}HM)DA^zWQJ;4#>}0dA$pBqqmLsnjdx@4ZKIWLNs&YOSQPgo>X^Id!gx|O{ zUsz+~lUPw~d?JO_lO@bNXouYV7x#H<`mOWVJgCtPk4I;MUYVD$b*(9j)V`a~KYoj; zu3weVGbuB;@;2Y+MI0$ban_>CyV6WJ#*U<1zOZc|+delD9LMe8XQ_qvBBY8|ezNc_ z3xHqg=CLYjUd%HXUkaQ4gfd7E%kMUneQ3yC5*nr-YTaYLlD_>{Lem@Ao0gOd{)9)h zml0W6W|@oIN_qW{Cbs(+_Ota&Z6UhG8hU2Joh*VH-_j1$#g~13b35(Zg`evqs%GAm zs<$39DXyt~G7796{TC^UL%PzSrjqybD&O$ARPNUit3L0E+c1HZtR^HZOJ%{$M`D~PmMV@WJ=Gp55Ic|6~}B7A%~6;Tkk`Drnj zYrR>ikUb)Ogu{2d>Yt6~bKbq4$#=hOY(_c$<`~zg2fjxZcH>qjzC5_XshmUB(i_|& z+Pu)$P3r#p!!7Z`^sty&Hd+nXrdmtCc_tUc z{sz)7=|H{z+^+ju-MAOScV!Z?d-Q!+rnYs}OCFyc4EF*_qI55j1WpgB4NNhH`hkvH z`L6Gq|8m1D%0}`wo0;l$KW%>b_gm$Fgpc}bl7(84>O1uB~jg~K5q6dhD^*o^1U7xX+l9BOG1tzP z-^>4skiK!$&o7cCmN&j>6^@(VoV?p5!E+_^zEgTdL}jg=7_Oli{-?fyR@ z(of@AzQg`b1cE2>9^cl^=;F1U`4a6gtI;ABBpM(s@Ou9hQ&PgB+yQz$Uh`O0e8z!QO8VGHy0 z@iz!V|8OFz#MV{W$F(YyUxRUDS`6z`Ee!RtikrC)wcDaB9d4@;zh67;33cB@>Hp-^ zEVmwdSXleUNI-gTwxFKPZ`m9p-SE8Ax4PRs#nV1?l=rjFC4E0umMx!<L8~5 zE5*fj5z>&HoVeWNRpUN}4s=$S+sCKRm+mv%9*11>Yw6KA9A`ES)yg62vGAHkd~n~y zBYid$Jgt?5f8mS>3PdmfSp+&X%KHHUDD4^3~BzUPC zJ2J6RLVSM`lCp%bk*9$_8}GN8R~eIUy>)MY6Y>6_N22q$v-9r3gml@K@s_3Y`3rge z2mG>N5T>riu;R($wGhFXj;>0G3uS*DkWxlqXX|H*s#loE@u{Xtxw|CmZZGSdKV$hWmthh(z#P z2|Hk^h)C4OQ;TdhR?kvPJz+Cd5s*Q$d6P^I^f*)QoGSD{HUnkG%aLu#P*)r#9y=Qz8eM@g7ryA=q{8F(RpEd2WoR=?wK-{c@|CpY$~JOzUn~OMuv`rCRew9&tlNE(Qheb4KVetEXTJFwMTrnyXu+1%XCRN+N|ga z$KfL0#yQ>1f^D4OHfF@ClN3HXK7LRA$ihgJ@k8Yn&vuSRdZk8|FN1HM>DC1;86F;_ zgK3`Dtt#O5*9+Pr@7@cISk!!!);<17pB$2OIK+{61xh!(*4g z4u@%_K(xI~t$qWwnix0u&J=)CsuLa$O+*{z!6hC~6e2|38+IYiNoo?05{Ti*I_O1W zd5E92bui2?>E&qk)144p!=r-qC+=$mhaY(o?Kl0Sr$zE@EcBRsr>by_A2EF|$W?_? zFk!*2jR>gozy^myiLOi2K&*q$*x`1So#!1qUJ6odEb@14j;*4VuH5Iznl4$=o}a$32Ebo#EI zU0Rf_knjyBDW!b0SIP}{8|utopIlfYT{=0QS~63yPfK;E72dRl&!a1c$D&F*QKFg` zpmvKp z{t|D@!A9*jH?7O(FSRsWaiQb7Ihz8j8Rq@rkMPEcDHE^CZoL1_p3sOZm?V7vd#p4` zW9A7m-nwgpeB+&9{sO+_;Y&?5p2~vfmlc)6!+opT^TKl25S3+qm?%F$5grT5XS)iq zkMVgP5}GqPSgEzr?(rTWjO-?Ozwp2{SVqeEDeznZJue@6!%7+Z8+&QE#7XhOlE6NV zIc8SSFzt@A8AjHUU>DM2@gx=fapzxiM@ij6NRk$hh41vK<6-1ziF3Y^l; z%J0Jc5#wm}@crjc7pS1iz)1Lg$&NJUfJMyHxOW=OE?rw*@m-JKK-%&!*SGV4x~ArT z7}&nRPSfh0!~Eo>w|$(+wPme33VHLg)1&bqxz6Ad;3d!#BEn-DteEjkN`F7JBYZ{l zDdv`9<|`XPAG4M*zcPie%PF8E2Rv~+<$_%Nic(TbK=CtQ>K>oQiG~9*q*_3M zRTLYV8&?`Ms%9fE*diEL4+tH#Qsmi5o6T$0OYXPc3QMyri#jxsD%X(RgvkDyDD|!0 zNw1d6f4pNiz)Y13ZZrj#q|V_bHak1EHisw4qb>zGx8#}2AANb-lXhwJ(j%=;=}^O+ z5LRk{_?UO7Dzl+?8&JF`UEjq{VsMsC!=Y!I{5?0vXI2*DuQL{v*)2;Fdsl5w(;ENaLV)_E zU5Vh*RxYb?S_1R=szjutZ2p!kLh;;s54tSaj)b;eNh=yERh&P&2>787UdqS??bm$>^ATG`nZ zPYXnj{=tubxQBDFvf-4AD4Y&4oHn5wsv1wT!NtZ{O~N$N_i_tyiuUcV&HE-HZN1P8 zX`VDGFP(wrJR#tlPQxu8-YT6}Ykyz%J}QdU@8ruX!@4D_letZKHp~S6N*kUvQpbW$ zqJ)AmO|7f}kA<|IE?M_w3$SY3G-yLvuRXDjH>)KKZdjO2Ig2w7ucx7FK3oCkJVyja zPjO}VabU(UOcQcE|CX7&ee8mC{x^^*J5^u=L4 zClRc4B|&Pt7LOH|4Yew@oE2m?PWHb4$u2oW-8S7y^0?o6SiC6vz5=$~uvqGT{3WUC zh|w42S&ysDCdhZPR!8S++^;xs*gWzRXQVRgty*v3oWG}3_m5)UGw(AI?sPy)`%!X`3JB*QS#JKTcXqX8 zfsI0DBpY`!q|m{6gHe@m>o9!6xz(bxK$kDSxs)nD(4IPeP$YSBts0%_Cuai%zO=D3 zoBVsSYp;UA_fBM=4$rc8LyVuoFBjcXj}1uGJO=0+?Ucvk+#|TqB-O}Ky?K}Cnhx`> z=Ue+C)w4Qs207Phg4O76HtY;or>&aFQk+nmi>uC>{A^I~m1#~!i-q}t9$7bJj%jN( zhwuw9zp1UYlalR8Gl4gRNIQb%4aVvV6Z-MOw7{2BC3XICLg~iERCajXu{@u4 z_vLM2@)Q*NX#2kDxZ#uPe0*4;FX)FI%J`tg()y-kbQ<@X5L)WG@$rW6hYQsn3HgOS zrLq(IGoTS|jXHS4)&%H%*NOh6QD0#RKKQ?Vvz)2{ff^5otxZ4M9m0VKTBV2=_xJL5 z@gz2MXX3+RERW8Y8Rs+MlmdyG4eh7asV{0?>*cuHabY4E>dNy^Um8yHiyln*HG=+~ z**Uu^E?(rjlMi~IyR21oOY!EJP2YJ{EyheM;NWMO^GrJFWMH2Mqp=b3UJPM_ zVtoWig4G+zxj=5}q4r4do0*8m1m-q3b?@qy(%Lj|uap&Hu}#9;&K17I?fHlbC&MoVdasAYp|#?y@3ZQbUUixX?bIRLO}H*fH5Lw2UwyUyn&` zn&!F9-xnCGQ6R7yCh?5lt>Dq*V_7Jup+_6oPWoz>(GuanKnfG z%oSr+ykQvU->REW8)Z1TCos+8%}M|G@gUOrK4PX#n6uQf2kbKH?+U%~81`Z$?T%f) z;OS8z?;@QP(wUHZnA|?)CtTFUZCNAx_{YsE4h^iG(d*P0Ik}Em>w%eB^*jxj-7siV zgnh$4|Je-r{)DYj@Y>oZk3MGG@clTcQ1CRAd%1u+>E^sLrz#Cu3S+EIA;@%%585$_bx zmsbAiX9yOMbP&Nl(VkG)J=7uM0uI6`#^($QEsS{Z_!-o*>H5C*!YThHzHHf?U!zFk zz9bByMhIq0Brx7k-w1O2+=)Kitsnh2BHPVjbhro{V_?2xqX^H+_(w4Axx<5hkyZi( zMxFty5=F(!TczHTphYIV#B3#z!`XYF=HVpABFS#P@pl%%$EGZ87rlAK&2UqliC&ZS z&kp#?w{oY%Et4=xQv#EWs~d(Yn2Or-I9S_=8;Q0+&>uoe%4fL ztU44O0+;sSJ+!yoD||n57JfK5b?<&d|4cB8Bt}pCM0lR>88=2gmR|}*Mt z@VXs2Jo~$^^e4i+IQ;c;q^?!ur;MM4t>;H!mXYJINP?dRmHjs%?*}Ix-vHiWxJ3V4 zym;~d!$9ar5Hky_z+ZO+W!dgMmJ@m)uSJJDuF>(43zskcVfZ>=tCRSex?>ANU`Z_z z94I{^n(T0kOm|CrMM9s53R)sOd`LY+>>;V~d;#=7q!dGB#tULw!V+J@uj*5edujg8jDj@*1~sdmeo%ekbL$ZCy`^;qE^S z(L5(JV_Z$8?j}MRac*u+2KBer*bBE~&CR|Dz8?6)P{}5x)W1hP2dSH*J^~(3Yu589 z5%W5g^|rV55IhP{5>~J0$e)a(-<(b=DyqK&e~aMGZS0O}NVcxp*w{!V|G7LI1nk}n zEv_k=W%HDen z6MNc3{cUx#_E}^oZE*3T^LDT`jEF=MiAZ!)tO;KsK&UUAvOy_b22%8j zmyo8H)9jr%2Ru(b;}Jr7!$Y=~wXvrVl5yaPpRQ}lkSASdEv2ZPm+>t zurhkWymo=qxQWAdYBUGoFwsA@!9s46#^(Ju?cjse3fnNbSJA>e3 zWFF?|t?0>FfX<)fu_eduk#SgD3!Iru>aFKdHQp=q`{6yb)-6)`kklO0N*l(;T44RQ zz0cdiQic=vZ_BQ!Cwe(?Jf8f|T3LV3Rgqf)ZoS^w2WaIr*)Pu^Ek5G$*b)-%zuwcN z_Ps)0Eiu6BQz-hgOZZsRzmnTl#TzC~Cxv0yNu`ay7=jMnssidu|LuQW9Re-W~U-;6g|6VGO9@1i{=beg* z3gikhUs6b7V6#wuARKL(k%2bA#=ZFX@gu$@+Ml`)&~Eyz3D%p`h=y*s8JcqB>&i4B z=jsbiz(ApljEv&Svq^vpYow5%HUWoguHAJ_q?CKtUw_04)s4;ra{km>B?7v!3YJ)KXKlDN~R_Nk5M>Eb{$}AB0nUB zzafZ)&QZZSNc49^wVesl0YB7)O9=0eb02)*2T8J@5c4NvGlP-0VAh3&g{_D6MY2Qb ziefNiqOm{qER}0bpe*8Kc0vJZ8um<#L)MVzd_n2IQB98CG24zMX?Fi->y|)aWTg|P z1`GlBmbJL#QtFbK=!TAHdcq+v3>FKV6-1w@s*;I4`5HpOPff5S-12No*dVPX2$+1E zv+@vsEU=@$w-bcTq0yxIlB0o#yS&RYe;Bam`3k{w1MgX$P(H*(DjtrAn$6A(oaao& z`o_CAxuQfzgC_kZ=@z5&3Z-9%Z3_zvgF8^zOY8YDJJc}H3Dp)BCKWdXzX~=clW-Mk z5OC!oj=WPaJ`X{(20_;m3IPR5cn_buam9K_Q}7|(XC3}w_^hoIdRQVLXsPY4d^i&D zq9`7XC1`b{_?n*)w{Hr64Mu6}A(D5Nm*SZ+UfFx@;q3>LR#Lb>^C%t>cuw?) zh%?auUac0Cc#Hp0F!44Ikj3kh9)i_5Ro-*=4})IBOr*Y3Mbq~7k*aov0Y5*l(sN)y zF?y#y9U+wQvZT>{x zu#ivL=jTVZiB+iEN^uPCRh_HsJzBSz&~>1AFR*w-sJXWZQ=!!o(f__iP=7$QdJQD* zehb`;4%P%`XpO@1mwQlJmIOAaeSgv())Kh_fNP=!N2Cr9sf`s1bW2uKQ$Ay1E0Q00 z7Gc53vhNc1%vCeGznB{mT!KZW0BRJRO4FsFI!BNnApV8$w+zARd~=`5 zlLHWVM53P$!%->+vTJ}a_!0a@cLBtIU%oBiY&RVtpbFCU0_efc(<{RL_k<&~{mIQH z0qRnF4l3NgR{7gNk(>NYq^7b#L=m9{7K&|yUrsX*Mw*|o>*1j=HU8)wV>0=-;vp{9 z3B-CxYU*`vdq%uUU0_o(mCy9y5rr*(t4Ta0&DAYHnov+%kT%6RAN_~H3?gMe#&(0Q zL10O5Ro{*qz~WnRjM!vZ#ftxa69lEF@bKowje&`m3&3gguiC7|NI` zAmij;HP4Whtwa%g^mV8IULoIEBuhnj)rOmsn$UhoTGa6VuzIsmc8I7>xs5b+QpTG& zzR$EXc|x%?_zS}wQf3>F@`^;IDfP^e+XO_P5w9Q(UPv>dClql5!2`6w6H&YQ^dKcu zg#?=CkkZ1JLLA!NzkiSZrKv7&L7CJT{?>(+8R0gpe_*>ja(4)?y<5m=-o$8);L&L8 z>7hG7miUm%UUN$XfyTyhoIRId;q185+lzQmR!5n<)p9VyPTe5bKe;8@PgGi#8ondk>-@OGx6~W zwxJHKYB}gQ#l9`vbxGp}w|&tm%+Jl0AfEv!E6zZ$@5^RoJJc-8(SPyP9-nF3TAFu# z(k-PEwpfI~j+1&__*urlSbcx6qk7`&1EFIeCZk~f_(8_8KAaaMNuLMZzP1^jboIzJ zzkeDJ);lup1oB~n6QQx_mAM`ehpL`g7K%GoNYqM;OrIp`nTp1|$Gpi+(kXiJOqJ5t zXc4N}nS3WRU-S_4NqbN%IDA1}$W(^_lR=6gE%m=!tYwS<(X!E=<&tH34%(wBqv{BZ z#_tpTGQV9b5QGw`rlu6=xdJomf3Z3!v3865gu?~!#2XwOz@LIYEvBaL^tva6=e})v z0+vIf_L}5)_{-oH1)8h%9i(a{1O^JTGC3E_9F((t-8MWQT!a5bRz3~1NjTX`uS?tB zPVm9PKt5kKk6^k*F4t*+ruBDm8MD(qMe+o2I+9HB^zv4k+vkitSwa#Dyv4|$wAZ+1 zwLjuM>i%68PPFf4e03DTk&Iki$X6;^2F*2hghaC6B2*Y@b2e}1%vJN8jAOl3k|YJ}to;`_ z)Ucn>Gs5sO#UexXw1XD2;g%=E)Br!hg&=T?0o8S=PXyn*Ppt{0FLx^fF!B}tl&_iN z&Cr7)3r|V$1?>F&IR_sK+F5ND7hFW-DE!%C@fq+X^aiWCyhE)K!p}+x{>_ zdLvDBUO`DJE{sClcK*Rc6Z+bu9-XQcA+o^6X=pTx5)?(J4vs3Q=`K&6=W|Fv_UhbN z;`f+O!@)?4*Jr7`?!R`zH*YYJRKn%Vj||srJ&5oyFb*$=dH*~oUN&r%5BrBfK|Pth zC^4@|Bbn;w?)pw8*3e*|Bq zV5m{alVR~;)adSw?BIuqCC`9ji^a!9`aGw>fgvfakv!f>NR0EU(Lq_dMAL_ZHuV-b zS2KpdI}jr{sqW`WVpG$aC{Jfily+X_qz~9=ncpeNh2*wC-yoYJ)wueH5{0AR0|Dar zeK|RiHPavu&Rbn*;5jS`#llvRBUUJLuLmfxjykmMtwg!g#~3{o@fyW47#eHl|MhDK zc6_f;KK-7NVFm<&;^oW#Z8FqjY8@*&rYI*Dx$oh=ph*L@z&Gy>-5mm3;>~R`u5*X* z<4W$Ql;1h)MXvHuhy>Uo25L$5)1wD0WK~DePIfUF<=*>)^>AmDq#CVmuIeZtrM`YB zry|35&qL;+p(8$X<3&{AvswxTSD08tf=du`do&wrO8A+t`A9_b( zb9>T0W|Lr1bR+CMcT%t$&Z3lu5P+VV=>}Vutg3^riuSY~HhGn)AHl^O9088*ShfJa zS((rdvq&>7d^<&()S*!2iV>iByxiA8w#5)Fh82ih8SJv-XSabfh-53CHPap}M_Nzf z(|*^SHQM1N;v$h3HyFnfE0fnX``UgJ#S7m2JZ8B^b@1c)F1+s_&|Bf3H@~{+pX)w| zjmmmG?_LH&zTOwMQ3~He-Py~GWC<7$#Sc6qXjWb?5+J6Q;IK#GN8vQ+TD~HEajNd- zNb_v0NPv+R)HrnD!X_3f6*d!m0z@J`YD0U|L!u~YV7JbGJr=#UZjd1La7N?C zU9Ar&0Me)%@Ob81qy1`$cow|;wi+O8fcVON>Jvoo>?j>yjIEG>po<(e#<7!1=AU*yuW#oQ)_+n!DlWc5(Dz@I3j0$G{l#sw64D&2PIx!W+ZYwC`W$ zN|?haqi)F0R6;)|81D)VHa`paWlhvec-5h)H3-Ly-E|bY?BE+zMuT(j7B@ec{8y(R ziop$9)3XQrb_SX2Xl*^E6GDQzQRVIV$lct7DH$bYwVj!1FTsKs3#H+D&exSVPj~XH zkds2NLTZmuXA|(z5efo>iMJdQS7BZq z@ve)fe)J8Xw2p2Ck)}pR9e3)ie9ryR@U8jWkDQ^IgQ(6Zu`XiD6mo&Z-z|9;VaUo^ zX%K805&y-LSD*XOPU|L5O-78F4f;Me!L{FmVf%sgdcKxly z3~gLP;>|OF3I9&yc>z1iksf-kSq|jk+Q1vKH^x^|q|~3PYX{66fuNecdGqmQ(mX58 zu1M!Z)q}#%9}dTG|6!OF!aK9Gg0BvKo+RYF3|i9WP&coo7{R42gP%PU2VU5e>frB+ zdEumk`QP22tQ*VXeioI6>k6MSEQJ1xeTAfDn{;(#i#+G%)5hK% zxF5?IUcNdAXUsCK2qNmgFHflOlXPz&oPdf(k&?kQw9C)9Ki#R;FEf_eY-2R&_B3G27WFWU6j>Esq;k4%Rk^p4m`LxVCX6#9voVem?Ujnx$Imi!;87+R{O~#v0q`8W`O$k2-r7`{@5TE?=%v^y+ zGRhGIG5)dan^W@4__MlNc#QI;2wwkWFUkrK&KGmNJL^H#={udZP9az$pbyKE_U~2= zbH>_q`U2+_LoDY&-PCM~t$L>E6_){aMYwSfvSvvJ^}vVZ;K5Ui&&Bs~t%}r)aK$U{ ziyMDz$?6>5i;@jWI*vsr-pEjb2a383XJ%LD?#&p6r~r?dD&Gga;5&h{)rGqnrdhD= z%fW)f6JR|#jg`ICnf<646&8J(dh%V|1S{1(Oe~i_=XL0UeRtr?=ABBZbucn)PiU}$ zGAZa6$g%K2g+lYS*v*$EIDJg*!?cA8T6*H;#2olmCuUMdu%eD_IbAABJ|YEc(AW%% z5(4=|W9Yz2)}sr>_G@)p)Kquxx$UvpW$zGqM#-AG!PU#t6e|mfANTE4RMapk2H}lL z#&-chQh6LADNgs{b;b9|i=273jso?oFH zdE!fEwY1Kv+s+?~u#9=9?+qJF>QW>Y1btF@fO`%-dZ>Z^1g>+ztaPFPw`|wT zkI_&1`*!Lwu6x%ZMMYvsQI9rTJC79yvW-ciST;|>)3+<|f}~F}i1ai~CJzbe87Yul zk9+NYtWfeu#*o>Mfw}VBiTi%OP9doaganB25+rr?+lvtSSiyQqdXcVX2HWq!z0Fjf zyt+ zl4|TU9VQ>oHd((wDXoKwZM9N?mPz3yjKgBVLQBFrY6$s6*Jbh)2pshvlt{%>!r%Vd zP|`&hn~FDVHJ!%B?00nl?D|$@b-gQnQTC%9wkivFvsIey-A_%P>c)oVO={{UU9s22 zMZQ|Yc;bgpHd7M#0R@-5Q*B=4&`cF5m9 z1UC>;QnGU-z<-MlXb_R4rlpCmLti&{HG{g<3sFEY3U{}!RQ7;Ieb0}YeWoRP^sud$D4j(q4OeVYG7?>ph3Wlf4*T0JhyuM z2U&6WiwmeG$d#oTCXok-UUJJJtNIt7_D6MPuHN#mq)!n0a&Ym75SGk844YPQqH?kw zCziY4W%bPR$*ViXA6;C;FgazSeM?#Ek}ybVmwUA-z!G({yu^Eu3-MK$|=cwjL5 z&zsJm6bj{QaB!k{p|qHac4qvw4RG6buAK{@-xglYPt$s31x7j*K6O5q>;TY%Im0nn zko74z#Z)*Vop4>V{#FYL_T`zv1kL^P!Z1l4d`>Nl6p&&KOaIoKLx%VAW~fV0p&gvwhWHgX%Kg`gyL8+s=Rf z=x?IG`_V01&(so2A|_S@L)YVx@o6hOntFrU6-xf5SA>7|#_k%7l`Ci%E)fK~@8a~1 z`AZx@nrsqix!7m}v)Kssy6n6bJ#pX6z^um0a+M}0n*6rD=pH1qJ&~L1q$V$uCRt`n z4KdmjR&avq_3sp#pg8NH+u*EQS-C5e>ZH${8J!8_=%=E&O`BdL&F=L?0Gsxb@8G3l ze%9l5kzi!>zUgh#mYDwJ0wvOKN2jw?<^hC|md>i87^x%&N)snrh(kBDoB-&+5H|Q5 z_^OSQ67V}heqZB^CTiB)dOIMM{0;JlVZzJ^&V#fyp4HPt&S3%EBl}@6n?fa1Nma{U zZxj!9fD*O23g`V8PB__YFYlbfAWis^@2)8=K7n}-q|bJRFX_GeMJlGKH{LX_HB`WO zn>Q~RHw1B2W*8dx3im)Kv^F(0g#R!Iks596%KZWbZU?>^M9Ad`Mn;|(L4cw?XK9rs z)VUu97K7UT`o2iC4N#8A1P$CiJIkM)#2!KO=9-E~J9|xr-(+nRQv`zGJdUoQp^03( z{WbP15`{E__uOUAz8V5X+~Ar8wjF7CMaHJJlw|$l-Q5P?Lf)P*`x0pXX4`Ahz1U9~ z>DQITbyC+G2*9qllz*? z(`LB``I<&Re6E~#SV&dH!ltZ*&>kShYPc%u2CMF|NZpJHrs(lZe}%}kkqT33K8u}@ za?lrJJS(ZYO-UM8WTNngAyB`r6DWl17mKOkwaBhWj!-+=E^D&lxELd6IFFuf?c|V_ zDD;e3GEfTKH6=0u63}C_&BaUSEx{r?mY!slHmM+yjm%imu)6-gsJp-&zxe%#9A~Y?}iWg#EfE#YzGQgZc>zb~Zp%=!_0Jd~b zk^|0?JN4|79|YbB-|$PmYdcR#3uv2XU30^e%-V-Gi*$nLnhJm^sw-9t)rY8aRe$?{ z9F$oOFxvty(Syy58E`L3YsDv!;hu#)U7Z4}RCZhTqv)i}t}7=b&dN=Y{q)^-u>oBamxrJm-a_ z&BiDSK30^T>_rO;Yg31fu})-1vX-5A6RQlXsF~`oP5?Rz1>t$=9cr+0kEw5y&wm^# z-pRJ3hQG^eSa5VAudfH$S#OzriS0YIcK!ZiQUd*?K;Z$&PO7R3n%YC8FZ}XzuX;L2lmBfolPCZOZ6bAFe$v#nGLK)VLKAGf zTVlgfUI>sM!1o&$BeeIv0UWXY)@p?i8%UKphOfdp*p^%hcr`vwtxKfzwP?z`}{2#@AqYXnDwzV`wh*oN`Og(SJHeYZ`xrCLPU=E^T3 z<{+t}9sXB=sBovfQTx*%Cn1K7m$=&kq&6Z~8D$%c2565Grf6(iAb>)REvJuWvyi4eg(MiXkN z$bNXjya=h^ya~D@VyEWTHomiCfOEdB*c_mmm!P6uF1Nj(N!=5eJDAW6gdr+^@u|2q z{g(A0#fm?M10I{s_q{&OJb3sHe*H84IsWdwc57Adyoy*n1*DO$0f{6F! zhI?$hLJvvhV30z9(0P1WSd1vj%{5*;HwL6S5$?jY+UGV@p=|A*ryG@wUawIWq0DV> z#x!X>tUzh&Y6Gr_K{QwqkGB}_z^l90@Iu#F4fO4qP$$z^s;9`5~O&O(`ETpQ_Dst_Ph z$jvwqth+{mZSN8h$w+d`Sl<+Gpk=0qwtzxed;B^OoB+wKlPC)Yb3L*d`pc8`x7uKV zi@U8QEWP~Sv-U-+Ex~1-dc87^u|2M*k+SdNL<|9rvjKO9A`8*r`ZnZi+Pa2BTg(?# zzcWgjqq71jqJJeDR&n&7D36P!w^E-pLQDUTJc`svw+C6;wf zLx5#AMSWuaD5^OyB>+Qeml7(`5g>4^(^HQTrGyHU_XClHnRFJlarPTArWYc_;vFv(XL7^4KXV_X!pF@1zJJr>Xw@i1f_bcW zJbUce&dfJ0w#5&kep?jT>8CU?m2!g5{?;G&^812o_MTOp&+Ux9mKAJ*ID7DtnMLq) zFn(~_S}cgU#<2SQ4+DX^RV_}*`kwAilm4-%D3~{+rxd9~posx_6tN|)#W_&e^B+|{ z!;rM_o=J#DTL8`g=%}7n;J-(4|ET@zJ?E$TKMc30zm@5!c^f~y?0Rw+=RTL$0@6Uc ze!JXPna%bdHdW;BW9wS1*m0`YHbH`gd8}o~rJ$`Owqr8)=l(EUZX3)p+}1i4f&84c zoDNNt_I(#v?SBSHjju_!Vw?FPnuFf8QK*{xf0%mja5n$w|G)22qE_rZA`!d9s;!cU zP@C4Qm6)}vsI3Ts7!lN{YEY{~%~~~sP&7eXqgC3pMYTm$wMKtFpYQj3UBCOfl7H@8 z*Zq3k_c`a4*Ex^#yeXZ@6OK@0KV41T<(=~Oi!HS`J6p&YIg#rmYKX={nPb>D!^C)f z0d~tc$-G%Z8kv+YGLN~=*!oFMs8ua!eAcnL7<&JmOQGhhR*g?*{!*m%qK=qr8Gq~N zg+HXpD{~fZFfSFzHDP*5yJ2CLxyn7eNNPX>O4F}hukOaz%XvH>bif*BPM;ZSSRjT5L5eCn*+s*(zl!YJ<=nxCfX#e1W1@#LUCuq5A3%buF)Oh zk@K6An5il`ECcb!!r{*~fu^8y_@dfoV$Fq6oKCe(#QyXZ7rUPS9X;Vt+ zdC6!Sl`it7{BE>zQlEZ8cqhg>{RW{wWGZkz$A{I#n{svZNWtD9NDdzyEPa*`szoLE4%DIwjQqYW=@EFVr|=* zUH_mrNz2$?i8$ZEFz@UCccvh=JsIpz!aOFe?{4@UJsfNN?4BKM5m;BWY;__(|4il5 z%1i8_LR@#qj7BBfdSBhemX8ZN>$TH{WH+QA;uRZ22|d5)Y#lHMkGrheEH`(`BdN6Q z==sz{oWdvj7C!v~zROpq_uk1E%lHPhXHSKNATZ65yacYSi}aSaZTnQUsLqTb&n zvjQ6*WNk)ovtXuzKqm@(B6Rm*u=6tbHyc>6Opu#H6WN%fTdq@;vx zz5Zsm-Dx8Dhriq3qA8{KjdvG0U-979%xUYvmbJM4`EMKiu7ByY)`-|R!S;V=5^^=6 zdT_UxmZA==o`xc%O7OAbWaJ|0H}4f8vv2lvb*GwvIz_N$EwLtTFS!c+#qZvSa^3Zq zNXLME3$TduDO;i>Dku8dGT_EBf6JvpB>FTIT}SWJnxWiym^sCLy{QswzL*oTXg6Qw^^xF`3tiLq|Ha_)@l zPqJ%%@6oDcpC8vHP3$dOuH+r7zCoSL{d!DNFM1>EThd)}1e~SJjpfwlJnNx`=4Jf; ztu69FONnZMTY(8j(5`5WT zd7;dyCf?Z0r-rtt9ibpp170GyfqBi2$|AUz83zx4KBPyr*z22q`eoyz&P&mwotB4B zvC1$0)y7eB>+6>5j**eMh4}$iRYW(f&3wT2`c8{?@QG1gWOUw4c5^LG8#A{4JYNiI zuV*}+H**RzXpggr{tfn+=H9%=Kwm~px2l?v0%>I))9WiI`(eq~0(K=TpnJ-rzQIYO z&?(Ia9@p}Ylgu3NE%QlmFA6V9RcG!sI7YQqHJUe}Cdf&q*16)@Y^ke9>8;mGTDKPI zS5>JI`KLIvG|wpt{eMX4|EKxF^B<5`8gy0-cIk%Q|8mf$r;YzRfPKxv4`dOdr?U27 zM}C2>z?x4`buTXr8VZ(iP;lOk>3JS!qvY`6`t|nQ` ze_%Yb(vF>FV6)(4X3%*e{;@kR&W0q4wNGJRQ}a>Wpj$nrHC~ll-2k|f%lNjaehA?y z!u{~@a8N*_y^Q8JvOWJ*vp~;i%#uohBKA;Sq9s2XHa}4u{&^}zc&=k7x|)dZj2zR4 zgC`*2_wcSQLq*)y;=pHc@YFnd%&-^)a9aNI&e7xm>uXU;715f6^9uiphgI_E!3c3Z z-*iOI0&7t+o%)VA#fr~AnawqNA6S$bh{1RS)UimyCor$q*y#m`!li|ZkvPTEdHX2n z>59L#pS`|~5g`^ZJP37weSM6`yV6=X4*?GsP&xgHQmWr#5f`(it1gqsi77c>)mxgr%ytAOs@(dp?Eq|r7A?^hKGzgsUDpJ?-s1Cf9ls!lZr-{`& zz1v2a)wPyjp3sdA{0snTHcF)Po!(71I-x8T0ta@)!QPlzT!g>6tK$Q1->9mVPDMsK zF)i|SB6**=cIzpAs`e?xr#Og8m({J#9-7iT0d4+$f$)7A*T{iV%%J4+i^2Dc9ct9yxpOnd^y3T#Pm{B%O|TAQ ztzbXIfl_&)0wKDeBWgI252*UFvMw^e@9U|Xg8qMQ`hWfO|G25zS=c2znH&G>r)U4i zPw7GJ7>E@UyImz{;)CB*4t)Frkt^&7>C7)feXhL;bR2Y`Y?)fM=+#$aU} z@oj1PmqUZo+n4Im`Dr|^0(3MeQY4ezScsHxPoSHz+B5U=t|2}n!fQfm4`;ctLcQ%el7 ztjzH4+|_qV7~wJ4JbDWMS3;gAD+}NEnZxu%I0q@C>1vrr&r(yDu^FoDu%u$tp;2)D z%0>ax8a@HL@FbqrI(5LG2M)niP59H=cBix^DS|j|8>m$RWSU)n)ak_=1 z#ncHScl`h&rYpCG%tjA^DxwxPtIk09+ljnGbp*0x>lN zJAdA~Rm7zLz?>ErGGz2%8yc6*%c;~g4a=<8{zo0b*y$v^t50}T-eeiESP2e04bBog zf2#ZLM~(1p9}7<9H+fuOM)Fx#pQ{!Coi|0B1qMB4x0w@leSA96C9?}08OXtvCWb4x z7A`z~83iLmF&T%|B4F(xVV+&Z@+cy&v1|>nuJpGP_}y~HscF|DgvZ<8nhy8RNfI!0 zCzM9)@zBNF6_UgDzC|BvYgJxqBMyi5-{(@1a z=+qoB-@Q*jT>$_Wz?vG%^-7$2AAOd-d1~K~QR0zu($}Fa2EKvL{>Qcv;Hn~-A4sg~ zf8=;f=lSpp52f|ddC+(nl-VAN^h5ODnNu&j2t4y26Vusq|MOu!m4`b${^J3i1;V6d zc-7SHyqPYU*rpI~komxH`xXr^pTh7Vht#$I+bhIkeA+8CydZa#BVPFs{g?mdQ=i$+ zA+|k(M5tF@WF@tJ{pVi)rp;k`;Y#AZVM&Pbk1_-_d0Tubu`_uw+?-MM`^k6fA2*CW z6M3jVx757GpHB0>-g14S?KL$IkTs{$phQKyT(DJQ4J!iq!DkWHxhLhQq@#ecxH_*-)DJpT7oW zK3BeVqaLtz&dWwwF>ptC~9i%O~A$-s0idZ1XP| zN0BS-o~-7A(+>c(7myl1VV9flLhoXoFw#C7r)>lYGm4hfY%fEK%uP``PkUX}+|SltRc zk4;x&&>|aid|6B-s1lLt;+o6pMqln>0*a-BLck6IvS^cuhUJap`7JAS*4ykx8(q7l zo}@?;(6voFZ2d7xkpXbNrK3fX%X-!O5=)i7`qvYg#zP1Rzzd0=sCLUMpd@d;)( z^mhzwDy`9SJuag&(nNc@dO71VW4fgo9DtJ?82t6|11VTyB2_Iktoyh=)hYW4Rg2%j zx~k-&;{5YQv9P*-XGmJFK6&Aee~s3oEH_4%tqt$~tVCHm2Ko^82#uF># z`5=d_(3hC(=C}Eir_8%AY}6@AWRaz=7Fxr=j^~6}E9QTH{bm@FOl3F$=1wOZGF!by`YI$`lTFx-jj)$jU zX*2YfMDhm|<5dfPlr{gZ@sBGtjFl=Md9@LH)Td6iPbT0-!D53z{Fgs{lIFCDZ`ZYJQLd%sj2D%SB5E2f%qz;9TJlzPoDH8p-5bwy z+x=M``C;KEtN9m)`2@GD5a=xGfIjNM#V;K#S(A~|(JOcJFz}BEZ0YS~MI!|RsU4HX zeAcLe2&Yp8iO#a`u@dissTS|vAo)l`%oVnAn>qow*@=X&VZKn^3*CLh#Kv3Edh=0s zjnscb@bTy){TvH9+taR`*?ML@&m9h0g?wMU_d#$bn`gevp@bskCVF&%z6AOb1 zus-QDX&gMT-b_}Jh;JNt*g=*sYc_mz^1w3OmXLWipxC>yy|Q5aD4$#qR`F7Xt$#LB zZ)2hYTh!-Lve?hTIa1AE$V`%hqbc%q8OU zH|6Ic%ZE+JdB#`!`H#o;h9`HUAI^QaYzsHnpV5h%1>*a1+Y;@D5VLl@ncicUfq< z7N=G_8`&h=C4W@-@d4tKJ|V5?9RV0#JAdPEYmM~RH0-U0FzfjFWbV1*@0h&i1ws;~ zbzWWPr1{u(tFqu@^EY!!GIg1h>uYW7+I&(20d)f;AHc(tm5HzUx?7As{!(}wmw|+{ zNzY`Rt^>g>J#B&PfmX&)v|g-m-}{TH*dZotl@)i2VBN7e($9LFw?aY076+luLvA^| zjNsb55tlP!la>zRUi%wfr5GOP8JDN(V7y>Fj$!5G-??gNtKwp3rg6(nPeigKnTgEu zFN=+J! zZTT7~f^6v5ZxMd<1c}Tm&+G{u9P4_^2B+x;8InEF9N=v`M4V4| z6m|TNIHEZC?+idO*~a^N6OfPqQh1(>NzJP{DE@UMepyZ;km=R4+1k}TdZP{QqLt_B zhljPRWDtkBuJ#Gzo5S&yBMDVT(e)duXljOa^V7L~<1(j()eS_$Ng;OF6>TQP5|V4H z^>bp3urcvrr|{}Kr$6di+g=-XWi~|`P0mH)%U7PFM|Px(?0aoKyxG@DR3&A1o+wnk z{qT!RasO{XxJ<}ah}GncxT;jAjG_ZkT-5g)e{+lhq2o6*h?|Y*#t^1?;|WSrwDp(Y zs>DXrG3zgWT)$;S?RI#zmK>*?y@y%t=-arfR&QnqyFGT+IB3di&WHZK7eN4XMtp*s z-~>~PW+kgd;8-5>;d>Uei@MHBO05<0{#W!@^h6qzA)4*@-c4e&4WujUg_YovHF*UY zQq(e(Q(rg9RDiABSvD0N5q2m##%cdwa0?PgAaa~QaS?^eAr2wSlvpq4=vvEny!I<5-q$& zHF?Fs$KoE@K5GKyI34#3uhCt<-E7~m({JpiMp$kPB*$d-(zFu~sZp?H6Srm3!#i!+ z*k2RIC}eeGOt5#YsM|-YW3#i2f7J+mXqpabgl<(l2%ZOK{06BgGrXo5>9W(^eJbxO z=j-hMT=&9DI8F%qsl6VWO(=^1raDd(Du5tyn}?Dt_v4y*>ptmxJ>-gp1@q$M%VcVp zAN-77lO9T$AITdza%o!$8WtSKpY~_DD!*Kx)C){ zj#5}clBGz$RrjvXjJjtd-mWMpSuVnobN5zn^0h@;A+PzIj&?=H%~h;`)8}cc+7Iq- zxLavMi(LHTOXg5I?OQcROJP{fzW$R(?*)f)d9hjgye295{xIzcx%0eQiWcv?M&zkK z7?H9n??OhcJbl$~$f7^bW3=z`1R}cf&D;I1PcW~N2G?VrVRZt$4R-Wo0obE8qH8Nm-#uEY z&9SPf5bwHnBY4FT`zlvN+UI6~L1C>2%AF^b6(g8qQVF~hHCO3O7xnnV_<}qXcXiC6 zQtu83VhxrDC&E}cbtPhBIz!T!mM>yIVXv>w;K3dtB)vKnl3smr8Wb%@Jhh8w;^+16 zaWP9w=-gpesc_^Y?{(t8d_n2D%w42XJ73Buk9}%)MTzJJ$M&tRnfzc6*$-7L*rXS7 z1dU&a^!ip8yK7O9q1l~koAcpi?BINUpcB|(S9I32s+a}cPAHe)9D&x&%q6vl%RW80qv(fw%;^j)%_is6<*VD#3!+~)>+b3!7E?H z8-K%MKD7u|dA+VMt#bc5Q?DO?&>onFbdA07OC(hYDcs&Dp6P*rX1tPuTdDpCw`q$K zyZlok@k3yk&)Y|(orxquc^TVZ$M{DZ)7AgG2bcdJeU4Lgj??3R($fET4-PZ21A5;` zA(C6@(nD+8J8J(=pu-ph0zhOq2{y{}t!WX2;exlG+h?+Mn7{u%PJHy*7H2Uw1 z%5||}+e!b1U-#bRZb0PH`HfEn4CU{~`+j$noMp0MXNompuJ*{@)|NhM;9bJ)UIcIV zmGh@le-g>9MGv%PhCSqUKP0flq1@SYML``y=X7|VSfz~KU+lD-Mr)?W)KHEflxbZW z7lN0mDC&-ZB(Hilua2P-WrAe&?+ih0WM_cSL+MCB#1~(kt>VPTZx8gS^)lDz%}ctjC+FBr*pcdy|He?OWEoG0pAt)hZd#vTDFO5EU!ex16 zThCI){cXgTbcw)%&&(n}`$Pz%0OMI({tSJL&`{)TJtzv&RRelwnx2DURtst<)sKf1 z#kD5zH=8?j<9`7j|qUNCvieE#ByN=s8;1>Y?s)-Gwgt^(DayqRJl~d zcsh7Ux*e&Vz@Gs{EwH5;o*3NYusqP>RafPeg9i)=r4AMag4rovHGUF+bsIR^VFV#R z2?hprg9rGwq`FIAc$TQo)Zsg;d83 zR+h;~i08QQ0hd(R%8;VEd<;|kgjkXL1+fL%y)BOuDVVZV%=m~Ai*4}!dA5MYG@eP| zfoP3=&F0wG6vEX}9iR71o1UhYZAASE=Ix2V+*y3sxdSNH(U-`c&lKdPUp@OWhsSBS zeEYOjjSC^PhNjZJUh<5g1c|cYqV6JC;eyw4>ML-?umWifCrWQ_>?Oa>9 z>^4MA7GcMLrrlql+%A~f)*7s6kuwqpWo=nZP3qE`o!etW9(*tDenA>= zDUSuY4evr{AXb(6c(#YTU2suPn_=5?E#Md znW5#ir#UUqqdT-?)@`lTR?%<>2c2^3T)WbUy8p26YMRf~m?8*y5eboBxRIcZU>`ir z0=f8#xbY6%A`=3>X2|Z@`1yL<1)7}|{%ZLyd7 z1rEI6xEO@`4wYik%wOoiHymT9D8(!9gpS@;m zeGY|LBIQc1geyb~Z`ES=q3#75{@~$J!4>7L>wLE`jtT@FbrK4*(s!qXa$LxW_01BS z(1LY#Utqhdqe#u?7|)Vy0j*laZrd(!1`F?ICMhuUDh&bfpfpK;yon(v(Nq8iAh+@^ zOn~kr@T-f~<3K7ruoQ@kLAWoz#aWpHMg}#_?mS)XXi>rnY~o#lGvQqx9C3WUSqJ*7 zdu(`rKk+P3-W?ey8LUg1X@{BqLQ`AnL_@VuJs) z@!~V0O<+SD@j&04Z1y!SSM^Gss9X;Pla_Ose1Ml6U+a+jf#C{I4PQpv+2`k|Sj8At z9Z^o}mIegF$JbOkkO@Vs6CepA#fLc8VoC!+CAi&*fVd$~8H&<5%K_%?$@E^skH4)n zI>c~xA7{Yi%)v|E+HQVKmK&RtrLCYj2}S?FbA=1+c;!hj#!j97-6{X<3mPS7-?LRz zDDvWxkxVZ6K0;ltu+}SD87#wo4p<=&?XrflzW93*q~=Dp!(F?W4+i zlIKNCOzkY?h`;|+(wypKo8Vw8t-6zS75$4xD4eFZ?K^N*PtvfsZ2Qu@GxvW_x3#sz z>dsCzAMjHi6L0BR-t$68oPoJ+SX^t;I z0xDC6T`qi-F zc$v9vqnmrM_Gde?%l1(!FIUk-;;w8o~eL`G>Di5E04jC;uYaawmISh>%SVq&0r zRvY%=Myt#qCQkMxu57|!Ts)V_HuQali9B{MJ(Ku_lBVM^!_~hCtwOxAbkKt#$h|6^ zaw0MRorwi4>+`9ol5^#=>m3JeSO3fT<1)=FRN4Bc2r2mL>3*st@fu%>V2jrX{PFre zXN3|z_kxG2&VB(SHQ@U2Hz65V#Lziz=jIsE&w^XH)w*1hqMHlFAh03CGsEg2e&Ixz zMzB=%R(n5!Ijcjn?PG^uY5DIy9dKQkssYP`o$F8hp1B7RRe@y_7KP9Ri#V1Kg|RX)n@Gy!#V5IU9U%88QjiH`;WY}B1|Y4 zCriA($TNp%<6J@RBJA>Aw5>!PFUP_;2dkyjrO2{#%DZxV!DRf$D)MtM@Xl7qh%Iqi zcDqb1nhgfGEZxCf#YPj~juix{O9a%vxV%8(QB$I`c_lE4h7Gga+1$CS`SxVFP@R3N{_0P@R;EBb#|YatMx4ywngyQQhjIbZpgHQeIKk07=mc(zx3Ioc z$_0`VsW1s;oJKq3zd+a*0lDKKkaBih1 z3a+}{G0H|i8tFf$f#zr@I4e(WyJ(}GS-m~XQ*=M!&AO$xWktYPEBa$#cqk$JF^mg2 z)JZGfvQ>1230?Z_EI5NYQ}8;SWx*e8dAD%=D+Z|;u3zZs^Px(a7BuL$D0-E1`6pWx zDhDv*!BKnG7_;ym6^+n8lRFd*c?6`~1?CZpOfI^|KzKaPU9)|jUo3JP15H5RiG~@7 zGzZ_DOzjA;{KMvf{Ddmcc{GyT1&tN=&lV0#nmn+fAJ8Y28zUD_`Tw|hQ_~Z8WJcmKsB@b3A`H3 z%8g#psDKNM)+I3{dfQ1h29x1JNL`sWJr7_7f?J^vJcJ(>Cet+I`9pIasT;tQm4!N; zq0a2S3K|b!421$K7i*>%Gxz&X-^smtcJ`~kiBFN?<;5FM_EgrqhU9%!b0uZ`vR}_7 zga4iRkXdwVQ6<2O<(yB&Ru}*}_ecDxRyoqi(+|7nQZntB`b4E@T2oB#dPly2@-%SVYZ>@`e$YCZ(fagH4Su26ggi1R_Ud&QpB zU2u?biDqCOSP+T5EC;TFpH~9DO?}G%-V@k%;1GOF*RuObl&Q!>c(Uff2klX5oXaBK zA||U>nZ%Mm(5!bri7Dh1wbu$uN_3R^uA;MjCdI%J04K z>)-dsu`S!O87~YnN1Zd?B7#+n3!1sFx=0)tRy{KM^^Kq zzwF$l+%M^6K5*^vsk`@oj%aMzPsDF)!&-vNPb-B&QY2=DFt9|-wtSAst*W7$j-JH! z7e{F~k9h!jvugKPf>k*?X#dVk8viFjR_;__FhViwfod7LqAM<$GT=iFK~6yf%2a>$ zVP^cM5r=k0??Ka*fFau=MVT;GupxXL`P9>l zVo!U;ueJmdDKrF3adyivY?v-`Xi1Wvc|Z?zpRZp|X{ZK<5ZQe>`^KNXCngaC)P1(n zC1<>RJmp`fMUw^9kWfsCxk;(zfiitrwz&jq;cvC4R_=d)kkWbe^R+cLJ1{&07X2uS z2A8#~g^hX=1@6;IX7%~Wg*igEsoy6JV|WTjk3=5)SN5{#g;TA6(natGpHExXp5BA6 zg8ErtVk1@m-R8-GhnN&}zLV+H>)$x{>$J-+$GQW)I}ul4myxq=121vmqBH{*h^i^~ z`0=f7DOzGB1WhpBaT+Nh(hWgx7TEPUofEk}SeL!gL}OKE-wGh+%1$#OFrUOtW5xD zer-vFnr-F~i(W`1leygaK2DtJN3CWK9Qc{Jnl0#+2X2G9Tp#Zdp5tj{0|25jk@lc3 z50uDU#LN^O(Cw0nzLCmq`gqm#YF;@Gk|W8Z`(R&I`BSNyXa;GU`_tN}Nv~3Mq|)u7 z?sfTAgmTeajk*Cif2O&P+lTjOKMTDuoQW-s<$juIoh4pioF&$Ba$BCfma z*-dAKi5Ivz^NAhtuh0qyf*}{nle5?xf4g()>Z(BA_mYp2CfB74J2s^|JnkGuo4FnI z1DksOoIm5^$zh*$$FQ|WdiGsX9+A$xID2_f_5?RMyB`Rw%df7aj40itN2hKs7WOaR z8T>GVix55(&IS{!;HGvEGv6DqwhOx#Hp;e?fC2@T(`3TH@~)7uniV6T{4hoDy0d zyjfZJjvsa>jpb}nbTnLY>aI(epKp5Rux^^$7td$cb$xyG`}_cTsd;d~jPuRcL%x}7 zT#}neR5;P9M0$&iuwi z*%@&JzEQ*Rdsb|UWnYHf(UP{7hrT|n&{Aja)H1zVR6xY3Q+>XN>2c}1$SKcfaVrSd*v3>w(S(JkGSO=YHtWV&m5M-9I?4g%6vK0g+&f` zm~E>&tuLQvB=1?cycT?6xPl|V|HPR&|5Yb_uc9740+v{h1SdA8hY9-*6v%4-Rq~k{ z{WG?EhoalHAT;g!0wp`w%I^DyNcQ}Yzxj{1Wz!K#8txRn&&qL@>-bJk%rxt%lA)D2B z+FQRpS$ICQXB*ot{0d*Q@XU;+VhefEk|PUn=LX;+mB??d*YvGE?B%Ld_*3E=-@ZGsbQr%MGA~fP zHN%|jT=ifnAiig9S=7Qvf{;w%hfSoxZY=Xh_q*rSPo^8%k0~d&u@=x!xV`3-oHf?H z&~>Lk(-10wy7p{wbKYTi>mlDLFjc~daz(8|DD|Bu)ESXvE8YCU$KJD+Vi1Wa%y_m8 z`ngahv($2tqaA9{t}?i4AI~Fc*+LD4pp0|)=7ksTviUF0TuCda1?2OCw$5ZKw5UZW(&3+0K)4`Xx7etQBwC;xYm?`6xb z^XV*}wYr-BU9|~cPIkg8?d+r2$PBWC* z%D-{QLJF)+3rXtdX~nn$T9=>Is2mEL;KI-eC7h>Htb9-N(axB{C2-GI#7tCZXDyrg|Lj7}DQurA_lm}RktC^wJr^Wy(W&paz~6;Rij@ol51OXP7& z6ZC>EtoE8v^BV6&`UBeV<=8jDA;A~KPC2FORoB258ezeVF(aPA`mocM4-GSeRY;L} zBHOZ|j_DSsZ5k*->FJtoWXq|2o>5pd1Suajim#NPwZhc%{U#(u)4@0ACEO^i3< zqRv$d6zF&o+lnej{Wbc|O`UCn}ddK0SU%n<| zPX6mn09lM4m6~4t3)3xf69!r@g@ruZ(|Gertn}mYNV-OkIqy*J{b$NJt1Dd6HoNK$ z+h4XXe4CBcI~AuvU2eU+|Dpnw5I#XFp`OFfFFz%gJUveK70d9PNWECdma8T@m)teW zzpzBQAOddp(EU~>JUOciXWkekCJvqI1B@u|>wIZYYS*Go2o13O5}DLFRHbz#Xiip& zj~_{CU&a)wVhp)2m4H&N_^ftDIN}z?cyGMe^8bUG92t(x#x*0$Ee8POo>Mbkrmr)@ zgB~$Ko|iqW%yjxQ(f4pW@l*`Y5d2`!c-}{;XVM|x{Gb5v7PFTvabS6Hml167-XY{}ef&i>eI1@#3n$!UPAcyUVNq?_WyZpB25r7o`BC=eLJ@$@ zqkEqfh;OyCkCdMIvpJ8}!4xSI2(Wa}hI0P~>o4K?Ir^q2G5c7msNe2q#W|r_&0YNXd6bI~btGA%g*qFhRKBi@ zOZH1h+Aty7ZRM54DOtucUPwO#&@bW_Qv zlKLr6yIi~rJ{h6eMy{`ZSS`5k=-o~!;kh=Hufi8$x(gos3%3?p=9#J@IyEU{fGgw& zihc(6FE5CM3}$y8adJvcYFtl*^_tf~Us|SWPX`07UeBalk#*n^qu%3uD(?toGbU?y z+DTVr?niTd)HL{TAR$UHR~%b(Oa_Z5Iso~io|n!}Zloxr?)fg~VV3Kp-v*f`q&}$@#EAW)UMU|WNMJD`NZ6qB~P1f--V0LUQ-eFo@M_FNVN^n*q3EU%2rR7j7Ay z7gQ*`4viGB;h{tbwMY2xdM!*TiKxV2-ZUNz2 zoYnD{dE!y}`eV;aV}ZsP-6I)ME5g`Z-4vuTF8^}QV#2W`<>&knj$<4b4zjA#NE``< zzxj8DxUc^rWNXZ5SQ9Ah^weL}5USU4G22xA7){Uxtrz(Bf%bA$2%qBZDW}GGubG4kz@dl2N|(%(1@B6}J`AH+#Q#z&v--5{ zJ16ks*=dxR1)8SZ1!c&liuUYT%mF(WekziXx!KVUs_fxx%QD+PS7m71RSX;2!Tn}szR~Gqp&GdP= zrg$T$bPXtFHB*c;9&TL7LsRI}An4Fa+Dha$*cp*>u~f@K+oZ^A*f-?s^0xQBS6QulPiw;GdkD$b!_6cYM^aJhO(Abo8Nkz#Hl3*H?tl&0B_mu7{9o zRmxwk3N-zw(gECxRtpwgCdI$o$RZNj5(TcO2!4UetD z@jsh=9;vRz-Hi9R=#rc|dON+@X{QKglWa=5xRu3HD}Dlx72Bf}Um&{08k{?9Mx{ER zCU$m&I~Nmot$3@#Fr@2kz7(Busc}Z`C~9`A90k^kXd#K7pp*$u6me}24cUHTXpCCs zcYxJHQH(*`_A&_@N^fqd2djW(4YQn>1vZUsXz65@#e9={8PFZ(^RP@(To%jBU{EaV z#Zd%8`7V!0plOS!@gi=sX7Th@fZxODcVWl)Q^ka*Z^$~qU(2=nTnw~nc@|CBJ?+b; z!pK|XTkJ2GY(nH8HW=OAozgWLq`RfN8|en= z(SlN=Lqx!hfzm1h0xHt?%l$mZ@gDE{2ke*qu;be2dtK+rzG5G%SMjdC`YLPhNxjTF z6VcThCE;i`c1le^aOQ9>_9D-p$`?t*wRI!928cFvCB9B9*kj1uscng_x<*09v_V8s z1SbgbQk1~b`vvz%u)IA-^)Rk}Wv|dJQF|rFz?Hk>evkL~$qxrEy$HvahIa&0ekyF0 zK)$}tk8bzO7l`toM=&GVd#+(=@*NLs>KiU>vSt|m!O#y9&wj5=?m`h9xbEglw)xj9 z@-w(!RrMIoRD4A9jQQ2&C)ffM;wite5B7d+ny0oYEDAICga3^0aw_HpVFU0t6Iu&X zQfICsRP62J?8%qq7t5M*%uknl^9D1CEOn!+d$=uXHtmv29i=FplTLZZZ!!*VWmF^3 zn}+GX#^gLHmZ#bpQR~GuIteVy+y8}68(rW*Ua?NsJyL-`T?>LrbOQniSyfY%zxGrU zUgi9e>2c;pTz97XrH-a1D>cevVKZa!69+lIlDw_f!4SY36{!^JBmY7v(UsTS^9aaY zk-&K2>bf|d=ePT$r0kJTN*;DjiT{Min!6VFu1dL;yMy>kD#K{B3d>#nXC-wXXpMJ^ zMeSOiinG)Rc=|>e-Q(&x~gzr_5dRf2~+xnvFygqbS=oPd(S~$_m`P&5-)lr(~ z+sFjh|De^%fkVU%A6dCR*#jK^gNF9X$g+R@?6kxBWvym|0U~p$P{CbGvp~!DdmEUb zt=%V(r^pl%DG%@xU%D66o!0;JE-8s$rMash)uHE>(LR-8BnbiQ2oaQubiq+57xr15 z6+0_a;Njg5xdk#|e`UY^vRp>vG&(<~npmy8ds1h2fQ^5E2=G|F%U17etL<-RS>?`A zZ7s))7Kmi%g?+^ch{6{e(A~=sjiis=6=Y7U+)>g;sh{8L#3By^$SJPdP+7+Gt z161;3Z7N0_HM!ks6|-d0K6jD#iNq(j*UeJTCK83OO(f~P=E-RPObT}pu@hvVKo9jF zD{i_tM|ES=_04;`m(^iBXTW8GQl)b~uLy(ZrwrdigC6YP<~>rD_riQaDsh5VcWV2L zc&QC3A~^CYD**}{lc&Bv0X)U(RG42F=t7>*4`j*J&a#lYhaFxv^+u-Z({XsVGtjBR zQ?H?BEXA081V2@&H=cY~&v*pS8(h)(CKFaL?yRc)1Azsf#PGybLvp7SeW-z{1TT?J z{9Q}uQ@z0KsoO-f@Qd0IHr4WuNP3f6Bj^H|-bB^XZaGz(*6C!>A6u>Wi;N@B*qvTe zm2rS4{~yr-j2X5e`|eK!Bu<~lt%aolZ>kt`K!9b>mDD!$SQ&jg(k+@PSZ!WS;T;vv zG9CZ?W2}>WBEPR)x?)ibmt6AFasb^AHu8nFMY7kFbMLYrvvN}06pViu@+g$G6;o>xRE;x5(jqaIP;!;Zt zo{>I!9+!Vr4Q>43CS>>%93l&weXkb4`Taamc0nLLn>M+gX`JDla7uqF^>Tv9@Z;o5 z{HUywSGc0oRMFT}PPCg^gsE(vtX7s3jfSs7l-zr{KYR~K`E@}Zl6}lEg;eT(H`*c{N3JLEB|;yLXnLg2VTO}OCX3GTLoKNJ0yviv*%F}r zt9kq0$F@IsI|_+>Z(iUx5csFm z`l5|kh<`qe=3L00Y|Up`^Ucc$PY&A{KR3 z06}HsL_|rud6YId9Td#QBI<2nLJ&dmiG-Szz}0)@rKt*6OP>+X$7 zX4gR=z8wm4*Ve}*g$JHSPB%PMq~MhKSG5scI50R!6(>}Y{9$#+#NvBL_Ts1@!9a~p zJ55`J3(xY8xB@#=oN-=A$5lOEmlF9RM}0MDDwF7*a)op;zK#%w2``}6T=z4p0N%21 z*?2M)pmjM4`&3%!ET)4OS~v9iP^a{cV2J!Mo`OdUTn}*1SRkj;xD#7pdp}LW7Fge} zJJu#O)i;c#-C)QGs;)P3wzQ!o|szvhChF<|J0E z&WqEGRY`76IR2TsqMbf`LW>L2E0j7+$b%Glbn0n|BTjJ$Qg>}nC|z2TfKarUO;T2A z^;4!`hBaqtxR-f}c9ETH+4yn#@txHY$ZlTvl=9ohjScA!TQhYl(mr&ijO-#(q6`1+ znvI|P(WuueXXMQp5k=N)+z?(Q&emdMpHAiDvAm^8_HruL$DhFV#qA`W?^Qfz<+LMK z!4iyvoynW$9np!8PNn`RP{CX!ngRPUO8{NO6*xJO8mAT-5I`qu_$)zd4)B?`Bi z&9?N4mAGB(X?0WF%}?8`gVq3?MISj)3dk+TIxRe?=a<9t@}x`3EeYstc}ZGGe^^Yt zXpOvMusCHU5x0dx@)DKtSlN8C!{34_q2m6^yyNYzbGJ$PGoHc~by@gTI=G6B^H-c_ zdro^dL_M?G%2}0wFCb^6xQ?oK={|@JzFygLrUG@;bC}cCaDUmun%w7?Yx51y{qh3* zTB{wY<$@mwOij)u8UgD6a7zFmYShu8Um3#p=LV#c>x=?SDs#0D51V@qV^mE8gXFfC7YNA;5J0P3*ZElHz2d?*o)>fh}pJRi|V3};RDI-qTlAgjm6 zpAINT2BI_|(ZDnRxj6S^Nz=VDn0cG{lns9^#4y&rfM-&8b^CL&VJ;t?!jBqxbp{8{ z-YZOCVt)Zld1OJ?b5c%NSWkrwUp!ZyAJP<;?V@N=3WX97n71Y zir9`oS7F72)e;TTKk>nSQ=e0`J5?xDrG-c`SxFlMX3Qrk;;>s5yk%2;kbO=g%6~or zF%DcSn`WEVRH_z$SRX@-2zu%q`jg`R0JUI@{clyZ`y_^mpDU$iehM+9yo`B0y^yCA zbZS>=BCx7&>aB{%tYdJlQ?7$m6+Dc1dBIbJmi5|-{CWm9C))0hUYYH4y z=aF{Bz0_EkdBPISb#sbjsR$QdKU7bD$gF!Km#{VW2Ib`1_hSzi#WF&BLPCT2Y(RS! zM47lLD`v9OTC(z#CiV5uE6rfnYP%UDddC^fEC7Gal6XEZ*DT zLq|so77m!(PSJjnb1&cm(m%za(EWuVl7fP=+_XgZACtxEV9!N^juUk;wT72*MLy*+ zwjc0>BRG+=K%Go34VBxtr2b|4REvI?L15+& za9?ePG2pcjFuy}$PPr&ly68<(CYa@(`cAks#nH4u$U%?(nRdOp&l@0|lgoLkYe_#hB>?GyUd02QR;3Q& zE9m1|4}J0oKF*N7J@ianj{6uFK^5+bmPL~Q*#ScA>;a8wfYo;}HXSv`??M&~$^B&9 z7Wo-?&OS#)-WhbxCX@9`iQ4!U$?aj3>mqpyahX)W3wR^|WI^VtE)J2cnNS0Ij`t+V zYO|DKY%MY&$k*RTIiGzbVb|Y9WF?79%O=C|FR+|GA4)o&nKwfvS96BjI< zwC>XvE5O%UvKE?diN|ClHi9rh|_FogogALHe*G(ojhdP1Ul z#**Lt8Yns%Z}h{GpZ`PNW1gvFD7`~h!Uxk8HWeKn^?Z*}z5*)oKuUnJ6y?+xiTE>; zeu{3Vp9cJKR#si&J{p4#mDZAp{oYuK;YT?q7!cU;RVx?0o%M2`&HKRRrFx)O>L)Z_ zim4etFN^njd@h)tg0ueA-T9+&jUCqSAAw$znV-3QRZNqL>2PEUE^VoKaR%JwX8;zp zJw2`8RKBzO>C{mtFr|$OdAWY~GUA`6*d~r3&;OR!^sNBEV>VzaqL1}rScsj|YmRka z^DQ{dQ*`{8b=S#p3a|C>jiicTLN>wP#45rIx1*N?D-Kmljo~6pmWh(vjU;XQmsEEz zqq<~?l3bihOp>dfWqVZRJ|o|p*9<`n11L!y0_)&g?Rut~@K&r-#rTOp%=|_!4y-P$qK3 zm`jk=thG|whyDa+B~HJios^b*z~>Ov0rE+JB)yQ>%fYOvNh6yX@WPw4&uh@FcU0CMVw-bO(mT{w%z}uw0(u&F zYfDv39Pc#XoZ@Oy0u$3<<@b5(!W`*II~k?!LylY1>fLLQ#Ey4$Nu?#a(F`m!?z<#QR#y; z;jg{~!7M1krx5k4$7K1mFatW;-E&bqjXV9g5_ZWfb7TQ&22@qVNeZVn4hlo6MS0CS zy6(ONqNFNlTXCR#R7-ng>2&gR{CQ%sB6G&Tm{enmdNE)>3m4CLIcr%c>9s~URZA_IBm3*D&dxG3+*mM|UqDc8=Y z)w9>BxnQ+%u@QoNWXkZ2YE9J2y5SysW^;X#{$Z&+yemp&-;KpNL$)aB$uBa8*;Js^ zWdeS<7e1-3`aNPzN}t&+VR7|wFc&NC_*ae(1m%}pi#(BoG0C$SygERrymEN#Z}8KF#etJgmM5 zNyAKKW?J&>*FDYZgZr|&C~?|NjLzwgoxMU(FN+u_B%C#$w#`ZAg7TI{RG-oXLA&G! zQ(@bD@Y!Bb;v%wC3A-}R4Sy}HmmkJ3#!S4J`6ZD8ESG48rGfmS%7)a{{-V~vE0VCT z@H~D5V4|a8JTE2D&`6I>CEgwUn1!F7Ll?e$RXCqzuo#?bOGAxv;e*mKGW5~1>O+71 zl(me6WD?&0nT&ONOCWC{#maK)^-6!g_xSz0JDkSLAweSzW3#q76UXEwun0daP zk2HP=5;+fm2ry@aYS1F8YaUfceyuZ_%_d4(4Lgw!F8}`L#5m*?J|)KSp{<_P30i%S zzcKb7G^WN^@3qVQ1imp#gJP5hZSrqI;kV8ckrlxD3vnZ~S&|5&0um>s0NJC&kD1-w z{AR3OCdI!B$J}x;c!J0k2cM+<9+tv~{bM|~96u5#^Du5rRDJGu+}V2-GzSjN3cR6~ z;GGMMzMmdvPf59H^ZNRMm4oO^z#zy@--Macs z&r31iQ$pNVJQ9;g5#PsNe;@hjLxkEZNo(pi39e!mnfUJ1eKU7m6~wT_N7=lmtN9$1 z6&ZWr+6jH~5n9@}K3%knj*fEg?uM;T(RPf_o)wg)udblZNs5`Eg<#A1MVgqDfbTew z?(qlfU1Sd|obJvD=ThF&Akp1EK@3Dq#PU)6L{~dW-+}O23%}=~%gk(cR#W}(4@KB) z(D{<L88<(u}(?BICJ=`ie=neKgIdx+L*Wp0yB@c zIJQP3if4C~RJ)117{zw9RI!m}>6&guZ2gaK_JD6Ym!4ys^sVM0jk50pW_K#Y%ma)ihYuy0s6xn}UYls}&XN39DttUJ+Q*@5ngG6^aMm zJ;Gxt>R{<4yg~mgryYi5zbBojc}vMQ!aoIDbm&@A1A67jBrz-LqOw){o4mz0zE&E_ zdh$?TGCpV!7jDR-{DfiD%DP1CKa#b5{i}SK#vuXg6{nsVO{4__z z@;k{zJU-|13!}4tPT0_Pq{DfjU>@#8Z&Y8H_WYHfyUWveH6ya37gL$?1Na*~`Yste z#MKZ~>W6{`)q{T*pmU#GHf003^*3_TQXeWk?TT~@O=r9RDd6d^y~k9~@_M-#MfDNh zcq3cySOm?D*?8;uxif{+u5IsM>*MCg=ErsS`re9GaDUE&J`LVc(Fg3(gBt&|7b~CH ze6#Y|)L%4YRz9VwV#+)#-QfpACBw2CR3vG7=5#+o`Cb)8oC0b-`2leC=amaXXC6)n zsj(P9GImM%DdFtkK6>@N1dd?rCUOGd_0nG-zbx>lQdhw5RKDGRd~*6lME;xDhjgXh zJaT++1}#c)?qRkrXLrnxb`l4VJ!x)=a91{lwBnAXI{3Mh5{?*8nN#$`V}D|K|BRDk zBKz-v{eR)A|J|`a)8x>|NLin^>`;G}{~56Vm#j((TXX?irlf?jXMg4R>SdYWT&X4N zJ&G}3;q*Kfz|0ykt5Zhj=r7+g{vteE4PyPmWQXWMM|ass9QJ*n@diill8;}R{7Wmh zA80z?eln9iYjd!d%#UOVf0n@6N*~PIzMlwDdOx50AvEuFbk!DZm0c0zgA1ipPZMp z8IdAth&KlI1`X^Sv~`LW088#Yam3iBi~ZP`dr~L@*Vh~0OmkL*%dk6L3E0}b*VE-avQ*XqHpqAm}UkAsXdhl78~QqCSM zS=}fDHnIkcr>h!}tYcnfV<=h?D<<2{HHA?iZ9KAPX4w(-GTi$hiQASGVc&gd9HX(k zg^0K8zTC9c4%3hBt zS^{;^3xWxB%lrq8!_pr7==Pftxt*Ck_=D-_FWEEUP5h7_ctwLE(YlcCxd#{181!@j z8H#$ZNlRRujOUrOa?qG;dn+m}Cd>~ z-k{!-?bnTlF`8EnovYTbT*#P{*A+jos-(s&cBujscQ0Zs35Ug%PB}u|0}>qW@lLxi zWxU4?M-X5|730dIq`DlK}*sEV2M(sciWW@ycf0s{coo9-V5Mm7@0F?`p)+`Z2a zWkal-T0yA8%edxW<0YKBhE5ETKW)An(~-sL`D{F#C=Ow7_`ZpL1N4x7>x*e}(XGvX%as1fn}Cml9?m@}%oe@@jGnUpM! z^W=M4GGqs{J&oUG_@g-zhQodc;9%yi1AO!T6$`hS3Kjo6XhFT5n(1@ZG^HV z8w0pDDp&8wWbzwiYB74&Hf(5}}EI=)Q+u`CXkAT(9=u%iManS0Zi+7@+RfqfXv^2>Hp# zZB77-mdF5NBfGgysDj-v#>yK0@~l{wf&{*=Adpr1`wM~Gh$8#0QsvS)b|?Lca@q6 zM~xXFLRaH`x1Mtyhi*tG>k-wSYUc+h7e$?W*-H-A8PyZ7`XRx=KYk~XwgWM9wr>ki z_jx`|v!V6^@3`HX&0mF)-5fl`u|6pMb%?g});HYqD6rRy>yjzEwTUn)zl}9J6pg9?&qj}!vL3`Gl6;6p; z(8kCqG}NV-oZPD4S^cr%UhZwqM!LqLn{ysH^=$M2I9U>KZq37me~mUa&q1j5+_GVY zouhmn#}I4wanQ5)-&x>N7<-DG>q0o&wUF;G0DH)Kv2#f5Jvd=8H+RS$3h}J3! zcD_hQem*Xj;H8z-(S!c4vTtA$;T^NUmX4g`6figu>S0wd>&5O14>2eSy`>LReE-4N zfZYyZQDBoG^-^t6hozg*HY@DZ>#~b65@S)y+KdEoLN%5bqdoA;51%GrubXXr5ebUh z_=Hqo@!fWOrmk}PvRfN(eQo%74>&nH+f>wv4514ZL<#1))>*%|@j4i>!{0vH^3H+C z#+10x{4Fq}x%4q|0{n9loL5G1^gM0Z%O<&a zC@=ez1VuSw{>6@17BA?a!9$6ac0MoqSB}_$@z0g#v(3nNUL6ip z`@mR*;ymVNEPK}$fz5fKcRCAaD|nSNJC{9QX}Jwa)2fCLNG{70meRBX-(poixeLkv zs$>RzmhQpbx{Q8G`N706jh^|)-LdDC!~FlGoc~2r|KF6u;ve@vG3UQvYSIG-gn1rk zg>{S8gLS_MG^GMI@AP<-L9H;S%s|KS*Y{>^X)v>R^F<}fE5>%Fvr0>73cE_$D|0Zr zvtt0ICB7n3&^4fQn{!d07p4=0@hRN7oLk6hdMZ4-d~z zv9S!Wuf7%7H+deuL>%{AM(0?elkBNGt$I7%D4ZRdgT$W1aik*`=wPgP)ai=ySOBCC zwjHpX0#z5kU$L$qAu&cIj6f1UL z!NtIg`t|_9zj1WB!Ku4Eu1Kpx`^Jtg>``=_>4a8ryiD@i8p10^xmjLCC_2-M*eb?) zrb4<8=G9A^A^9)I#wnHbqOc&~|7@=Luk?Ie5kY%KK@-DryA9;^g&(QCPJ-rd{$2 z#`m|%1K6lp5dx+oq13;Qxaf8|_Y0G@4U0M~J+w6T1;tA~^QQ*8yJ&mjGoPk7M!=5; zAPd}4-X4~oD@+gXD&o#^;U~+)w2XnNX|uJN7*uZS&S_;@86@LEKXq2l5*qAW5&6(9 zmz$HX+#G`C)XCqQD?hO}6Y}G%x*(;KhP>M0($k>|Fn|~H9Ne0e&dLWS=x))fr(tuY zHqo(agu&B^=M$d;V$}0z(Q(hpA|3VRWYbax9w?Cc;iAm24)q!YdBHZdZ7uCX?=ACm z^&C-UE}4uz=fjA@Pw2fTwdzFteXtbK?-Y)QzR7AwBl_#f`G+kB3L%02pt0okyZ5$$ zs%R~5X}Hu{;LQWwu!mIU+%M?(vFBn)Po>*%6na|QOpkM~hsbEmE~*lOA~b`kT%VgU z9a$COky3NT#xL~U`Ng?9)^Z1O2*qM=PKAsNbxha(3_`?=Q2OP~_T!KE6T)4s6s7 ztJ`4z>?p;%_V6VFbDl}5+j(D*#qKORL2zMt(EUoAjWWt&7d%jqjl7j(H25Ub?|x0N zam86YX=PX2sR)9xmxrS8X|wE7jT%-zj|gk|O#DkOwzHZ-1C57z*AG9E{c;(I7e88? zMJjO2bo7-u6J6kXc2(qw6 zN)-zrBwa_*uVy}^1(=GBgz||ooDFaZJ8kkO1kiOv>I!A;@@`IUzG=GM=DG)$>KkZL>e^?0sor|Ho5IeF3hr?%asF_?nl)!9AjQGDy zN0O|J+_s$xjAZ{W% zrFMwkVyTxuB2&$NI`J9FiFtkLIuR!29;Q0sR;zc!nZIU6wcxc0bN|kA8a4{$r|+vs}1Aa1ecrB3uV9RC{KSAH^LaVBLHdyrGYce|)>C#vAA!S-opP{j_&B%Lx^ zjGxd^JY*N46)gyo-wJlHzp}Nm81eJ&28n~K=j`+D@@~Bp{OqCS?=6`|2kxCCbTHS2 zPp8PPf=9da-(_(muU&<%OTS0D6yz$nt<*$%H^;4`ruus`9pn;a3!NVZUcNfYjs53~ z#qs!_Orhm|Kp*kJ^5rPlA?E9%3lN2K;@!r|C+g=ld+|FrZIPq*YW9#sl2we|VeetC z+S|_RF?*M3h#USAsV>kpXaGye+pZq82UE8P{}4brPO_O^iMhW+Wm7LONo2xa3|x@f zl0WIMfTH*4@Od$2NbOF^d!^6seF**$-(sFNxV4%=Pv}CnPtdWG9{k38&hiFw95hA- zjbl_UOQtnR2D0Tkb`=HW72*i^RQBIyBGj(d_H!p~EJ_B5e@F@{MhR#oYALYz ze9}}e@h#r=@aoo{P`Rf+XH4@sw0l2M@RiAL>#d9z1jB2RHOH*;zW{9?EDVZY+-bHqs8d9;MQSvIB%?pV$zBTt3#+wx{z>pdG8-Xck85Z^dT~ zU5obJXY2ohY{f+eLj=terCug%BPRx<(3UQ`tKEj++Qnx{#V!LK2d$u|g>bG=T*LFg z6sb?36u~f5h@>8DC16DyNUW-3hW}ujH~W_*uq|X>Sm^Am)N;_!ZJ;}25}~CRrKhdUQ&A_EPuUN zlJN8${P);i6|HcX*RCaWw)B~ew{Lf&V{yIsi;y2B%#C`^9$ci)SMdLz6^KUmzXz88 zvI0pbK0dPo|0jZ=qdi9u>v*V_(zaim5b^4=@RODb6r4fZMSRq;P;Z7xr7;2*$j`k| z(w|FGZq+5EO>55|yw2RHk#he{Q+!!xix#A|e@=`Pa*dZ&Mm)|*}=3wZ!P-8s{~kwW83q-Wcl4!B@p-&BpQ&cYZuTwbGy4U zDopWn@3ZK&g@q>N=XBB{8h!$H-d3ItFH$Vhdpr^T1#dxqQ3aG%r@1J%V=sd7j+gkd zU0w-~&%bW=?>7EWTADho?~OBxnZE5Qv6Br_+_`rY$}O4yGx5 z#0p8KDPycxs@6(> zi?U<8L zMWV@8t?|UJal-V;f$pwWC1EvDA9M4@-ED`crCNz&0a z-Q-x#^rob6Jp}6XgZnoYi=^94d=Msl(EppGC5GU7!wKVJ(SOhYVNcjY=>VNkl{bR^ zMhmh1Cbdk5)~1<>mR`IV0jek9L@lVpZSo267V925PCsDj6?X6#UT&=Nsq68_PeP6O z(MpV2)CUYcVl)ywE3D%6c%`ka&U`09c{7332qU8l9qW=2RuNpBpZ?Ort7*p1R>kq~ zxNXYjGG&w0{b0Jd)GZ$t*LN~`mNf6;w<>WQi%8Wv9u_uc_IbXUROCr_|0ZTk0nLy_ zsgkW(HbOcrwk%JuW-xL6Eko0cu)`B}l)@{t(`;wT(_L%dtZCn+?Ki;=ex${GI$S}! zOVM_7`YTDkU!UWw=#AbK)GbA(U5h8~O3K1*n0Na+-gOVhbzGZ<6}^tl8L7^<2UqdG zHdU9teIjW7NMgLw^m}N0oh3n4Pc5yKkXEh5Qe_>^8}1_ojlW5~PT%f{QsqsyE_Cj3 zAX2x8dr(7i3E_l7SAk9k4vP{S3vr;nFcYG`_`p79tUjK?uE5kM$YsC@7E7mhye)1% zbDIMrOPf)J>6;CWmJ%9TC7`v@b40R#FX##g7i3|2)akq_c!6KcpunfzW0MCm<(E-31o8kts-} zVBT2W8_P0YPu#rheO&2e(|IzB3GmMe5jTIg*~=;$(qW;HwGj$v)m#z*QGcGwVN*0WD4H0uY&YE>CYjPk4BeCbmD5k@p3I)ExLB85OI2MwM`u z_&A;ukGT%u_K1w3h9Vtvxfu)51;CBjJmIa1r)Dw84mNOzm6NmD+ZI0SL|ImNQF3 zcicbVpvk-eHk=L6x#TJIF8Vtp(Q1aVCtdp8QTFp1*a3qd<3kI&?IaJ1=4~933S1e8 z!XIkVgf>!3&0g}f>vArL_@Sq=llOPm^PCuIqP^hhA;%GU0c8=|$Hatiy0XmRS*;6l z5uf4gjtE#b&g_?VbnbS0a=*f_7}eL};f?chNFO@l{Na>u@c~4;pdD&>PI?>n5pAR9 zd?x)vS*5Codj=o6B}W(erph^Jg+<^4S!SybwA6(X`CGiFI#Fx+-9j1vx?S#ZDFUKD z=TiTpZCyzq0ndha5!>vtbn#FEffJH3I8h*BW0bZUPok&M3%462 z&LuuiV&hgD<^o}{y(rgB=TWi=+6bOD*BobqQNsuBZBZp3Z<`4lVsi>>QukLB{c+h7 zgta?Np=lnYlME2u@97Y8K-;5g2yEX<1-eSK`xfDBN@M4bkoB91fXl=~JYR zkEpncP*|AiBrq)mO7z~8%`TH9Yds6x5~IdD6iUIbi@5e9a!G+D9q{kg0=%k28N}L- zzz4-b)3zmJY%<*-y3iGeZ^l{ek#vxEL$MnIZV9O>uS&^=Itde?{0c(FxfKUAOD4<{ z&-tb$gqrWL$VS&M^`}&+TmhNqZLApDh)!Uj>mcb{qtQ`qdV&Qy_R`2#>2_E{NqsHU zSe$nI*G6Cy-niIA)32$7RBpz9?bi)ks{r0__VnIi(b*I(S=}eS=|QtvYDPaW-qcKp zXWf3cO-qIUV+m70lhsN@z*fP2DpX9B#_z?1c15Z58P!_TA$h4I!vd6KL2^-)EMBxV z@so_Efbm8;*-Ci>;jndn6TAt;SC@&q-df8K121Wn_GPI%5{niVkgG2Zsg0M_W&cm@~!h-?Q;Pe)H> zjZvL}OlGO#xCd?>SylJNKvkXoKtPQpjDlwn#}-u86#4*RdBV%QUG!^mIUs?Lctx#{ zM=kakkV0bD#NF=-U%a5pDAlvS-8W})6wqqydxxjWBObKeCQ3}~l*%>}D*+$qzfhyMUvD;6trQvnj4Ee* zSbvWPFuiv*isyCKneM?%1WlBsOQvm;6ElMp;XpVhudsx)u1zf$U4|D%0kNm^_-pMF z(b5E6J-FbIJmj)&D$c~GSkzV2(J8}KDL*IQiB1uTyZ7LB&1ZR?TB4Ne z4Vr;}% z6X9?ps8>cO=5hFwSjbGlQAZ0n;tlv^xX@5MY$816&u8~Gxlg-}pX{4xMzTu+FcT4x zREn1jkHi%r3})&Pc!q&UwGI7-qyj&*j;8ER?1On#FLy1h=9LKg1JM-Ha|{DBi^Ry| zeB7zqF?k= zp6_u&t=1r%+P+B4?($5SV5wHZ=^heZ!n1~8@0;hB_VPv+o|G2SV!+9JUOEjFlHGWt z{}kDW%)#g3$2C?{OV~~nc=!cmlP;M(=PO*p^z7EHQ45shH_~a#kS0DkY6o+@X`hl7 zGu$PEUG@<+J|AbE*Y@!68Qi2~cKY{RBE=zaD+VRM>)17f&=J4lKkMYOn*?-2s`mQ~ z_kzA7e zaQ{p-uUbG`4K9TZ`IL3e5nW^V7l+I!HWW0}2+7XJqO{IU#&B9lN@+zm0@T zGK*cve4pS)87hViAe_9FxEkA`1666+)qtld_; zOZzhtGMTWbK8)`k)-qXep_Ee3sM;amqUq`(bj;+(wxMfWL@w#Puy(+sEo%qy~6At@M z8p3Iz6c~t&^(DR}OHXUP<){)o{=jz*!T2pBy4{S-WO6-aP25X7?Ra%wJ)MqiAQ=uT z)Z=2CN3c9P5N(zhZXJ1_`d{n8QprDjMLyr0H$`3#$^&A5F~{+;99VyyE1^ANn6fcQ zK`c#dDKv}BEUkn)Q%SJ{>c(u`WBt$g1uSPi#zSMH@H$@5Ls&e0x9wkNiY7TI0okPm z7yMiIc_gm2JI%Lov>#@rCZT4#w}8oRAy6xLz>lycQD|?eIWde=`^9-9JNL;dkYXb@ zSZd=ym{T(SCb9=hhxn%uYnqBovDq#qFiK;2h1`08%I}3*R5!H+#z+=lMmF0z!N}{< zb81F=e^KfHz-^kV2w4)I%_QK(gsVfn-^}>sgWezb2UV~mMbNqg7A~Gj>W?84U1jOv z#KJJHem|*fQN88-k`~?Pi3K-*n&O+58{D@UE)pj%wnI)>I)hxn77^47*7qV0s_mH$ z_!L;t-DB{4_}8)&B@+oP({*vy)-e7{9?hG=-%){dgB~X)N190jyv`yfaaA|~r2cT6 zi*?3NOvr*1)W)<&!sr8lY=KJRKHZHOvLx}3ud%Vy(>R;j=Ptp~5IjcSl>bMmkpHl7 z@Kp=&QKTFxc(mLdHQ^d~EXYPw>`}3}+g-ePTZRKU(xH5vaF#X)U1sA_B2VFNqVM_3 z6QpQ1CK8)*Ovy=rmtnk1#dDbC0Z}2`SmR;<>0$3IwE@xn#~J;fHAFm9kPU>-y*IWA#6f(g7!YkDX$V_6g)6Tx9Ht z_)5PGW4Tw@Rch*vfb+f1DKy};b=%K=3*JH6L`)`kUctN%wdf5R6l zQbn<&kQbd9wEZNfWZuzi><0NsDxU8(OY?TK!5>on+cy?zjdG4!Up%?9f-FlKGJgia@6wdxqN0}K5k!t0?A{Gsc7P3x&ksjcabr?bPZ*OYTr zMyh*)%qLWC$LCh${{W_8E>|Cfh)kD1wERIkE_*?E$>c51*+}Kyx=f7YAU5U~Y>0YN zHJ7thdw!J~aI}riVAALm5|NUf{67FxK&!v&KSo(mNbUegB-<64P(4QM0Eh*m3sDDZ ziojfO2IXIft%&&`%1Z1fv{hgb1A;|`87|Rc9iXB)y}<$O?pw6J<1$x*QxskZN{z}? zJuty*cQWXCW{*=CV|r`Mq7UX?DPzTI;6+(lNKG8Y%N!@-RCNlM8ko7Lm68qBSZ!cm z61wF(k(|V}+fiLJOtQlqywuAYho)wv#L^e;Tv9D%OGQz{KwZH_HbJaYY}|U)c}mDx z_YCC~26;sD2=e*-+{~l%b!1OIlp{Cj=3X zP@NLy-wh&@u`Q`?qhz<@dQM_sB=L62N)X~!EK2zhT|aR~Dfxy1pv4l|MfYVy>bHIcf9GuOVqHzUvGKH(QCq9z>N5n!2 zL@+2|*ab|R4dpMm;kjwHC|BlXN#QD0t^{06Gh9I0U6_;s3k1ZakobD9`>Sm~SUiS0h-Kn{2#aTeDqt0xfA=W&Q5+Sm|KGfhP+MjeDmIl-1*3GvGk7N@oq zH~E%q2XTJ>kywskYMD5O3fpTeG^{eQbQko+pt0a!>W&8GaZ1b=kS8r&!K3xW07gC3 za;Cxp`63IXZlcJtoOdcjFL%i<=^rscRr1bR_blDMV6ZK)W!^{^RYutGZEy;rK4Pq~ z=2*&7FPH+0_?dOSaEHY3+_rOe%C3z}mhr6v@=ZhYR~WX%aVjQ|YO9Jep@r0SGu=mO zBPeft5R#qu)Nq=q&4)6IRqg5{rlx=C9O?~$m9meBtmkH+s}5tIaM?;Q#(}P)wMj+M z0s{jXI90xlpimza*g!9s#^+RYBVLAILUlqSKJ62mzM)u%D;W*TGRZZWi10I^H- zC6N)ndX|G8h>)S;HOu&zc?XstRy(;$oY)o*Zf6{JXOGY^sMkU_ zH|2vOhnh{Nn8hD(w-yePg<8WRuHv=;^BKgacq0ni3qS_0S2e?vW>q$~U3!cRYibGx z1{7}4;Hcm1R#=d5IlK^;P;%lS2aw!NZP47UP-{0WMWcyRk~q~dmr=x8FK{3p*NAOp znhXSS_zVQ)n7#&QXnII}i1JDuptmy-=PGlc@iHyGU<|A7R0w=ZNj|0~A}ugecZg+8 zLu-z)31+M%pcP@J6T}Kw{l*GFu&tNkB#1kOFh%hwZN%aNUZf;rRT*crIyt>UFKJ6i zpcs9}U8!`=5mz#jCG{_H`H3{d4cU5*RZgJYCsN2EO(6yMH7hb+^(-N0FGS%L_byvP z`b(H(d`GxWp=)ck6AV+VMWE1$1xnlyRPF_6dbv!&0?TiUf_(T z9I+(@#qllgGE-9A06Q_thi>JPa$TmQ6-eTy5WG?jVO(lGu}y<=t*NFNGFYY~8eFMt z!zluFh$cl#RHlr&+m#{?F70$f@O2s|!XQf}pKQJ{FyrwR)S;S<36kbjsQwT@!_-^~ z9$5J{)KhpRfEVHy6c-1tea#ZCdWG0NCk29tDl=eBvf<$1lS2~qY2*`94?p5BLEu;p zUrD9;7_Ih*>ClulG4ZKR%$EXdQ!Q(=3(?G>4s#d0%d~a4hTl+6`-Ky4Qo^Wbh=5!H zf@g|thpiQEKiPATTT~dk`Dz8J=q8*V;TFs(69ZeXQ3X^OHqT@4Y>QKCnX0IjKtP05 z%(u8B`5J&m1`mubko6q|c+W#br}vs^Eq6rhIB3=V>s=LT=+JyuW*B2rn@2J z!^Dh12sLV4RhIa)PnY!5Fdi5EcWtFi+JXq6XqCTwceLp^k!= zg@2h%bA8Kdkj7OJY8sfVN_1SNoRCR0aC0uF;|Wc&kBTukNkNj>8>~Qqa5Eq(V!3w` z-BdGKbTJ(O(^kwnC#h^JakAKfDFmigJis&diEXLOii<8%!Wfp>uf!}d;w*}JtOCS& z5uku{GNtp7BVVQ$&At|1=y+h*J(8CJ@Xc4SLmeb0lgkALtD%U7i>RyxzqrgLEV*~6 zhP*6LF_nD|eh3u|ZFaq|b9ImIC}kKv`i@x_z?w;@LSn#h>9}%V#Xh2Q|wk)kA+Tid-3@*#jGOzajxFtfk+Yh1?is%gf zV&=4X7BD$&0t^DO?3r-Rpv{TOR7=?LN1_Ww9oqd6m3(}Y7(JytY8=%I5pwz&;sJ^< zs1t$iw!>rZZiNG&^-~l zrSeqJA6Fjl2D7-$1I5O?rg)Bz^#;=B#jmJjKS3y(-(wk4_=pXfJrIE;Ey~|E${Cb# zg7s5-LZWd8Z9@$e%tXTwX;cVZ(wOj0?l6LLa>bfJEOp_8Cl|xAKFNL|%3b?nwroAb zaRCz@HG(GKuQK4Ed_WxzRT&{Nm>$_)ao}U`n3jecS^ofF?^e~qXts>Q?iC8nDErh% zf!qGj4Ux54m8G2b_=T!li4N?l@~_-tf&-WVrFw`)mEA$QEXcdYrZDp_vbovL4r#5PzkDE|OhpPPZH$^yoxc6*c*2za;VRZist6mu~FeM-wJ<&Bw`;-Le9 znL$WvI_fFALiHb*X+joQ%t=8MUgI;|vMtM6U#K#x<$=XtsMw=E(jCA(5ut>1@mAD-#0;;`5+_)bJo0j>BdS}3?+ybSp3y*9Al!I1Rxo8&P zB{s^ViZ~~PK9q~6rYTfMP!k|&2;E+yL}B6_9Z@?i@x*M{MA`^s)~679gDe3u1L29- z2`WMPA&TbiQCNC)F47m&KN zC=|49@uiHXWGroo0Mu!Q;x-2>1Uywg(zmja(}o$0Lg=*CQYybKQO8z^9uEtwDlTMLa?R#71m(G8(`cLbzxyE z!ptVNRxYmPfGsa*p<-=|^uc0@V0JJYE+@IFNx*Ilp#p|n2zFTQif)m$;GZH#G^fll zcX|;F4ht?_=Jd1uF#@Zv{*2)+Ykw&0%j`0G>L9hbc_0=>n_r?c34WaWV3M}7SHvVv z)ph6kH51FjuIcmJ9ZT#NE=pyA(|$2pJ)J9ghOV2kzY@wrS)&z7-Q+_(U34Gp z_cc2BMpUCJzh85!2x0^Z`n(5NXuaeQbJ#? zE>>Z;@JgV0#Q21?sZ%Gpjt%*Ubi7Jzf$lYGVZ5H81M5R53Ua})0k^4F!Q5Ph<%Zed zOTkOx5g+Lgp{)-K{Khhb&=)zNOu%76ELnqM%bFKGCK3ME{-KQtEqSGi+VA02J=x446^GwTdy+3-!iNrt!gsB zXrCrx7vauQ`+?Gw%;C;5z8JHSuHx}aW%`1>V7D@im5{_292hD;>{E4p5gJ$D1PgM( zRwA3riJqS~(HI>tzx@zOs-$1rE=_MAlyHz;82Ig(SitUf^)6aB%9Rp|lN8j<5myI%*8;+J7&DnVK3qwsggW_9-y$pUK&)HDo9-=96`D<3eDXJoi88%tO zVle7+VULkWVg~UtgQLGubUQS^xWT#}Bevs#q7@K!k*$?w?G9mf zukD!-(^f8aG}nJwotuQN5Vl@X|!+D_vU|ihDa1$ zd-E72VGI8N30ZaNU+O=5y~<=Gv%B>&k=R^r^m3+UDHv5zeu$Z9#eTybj<~UWUL_|y z7w%YEj#j>d5GTd*xVGd%mXk3O$O55YxPlm#o{Zo6i5!;pHhN8QHjQ_?GAEIUL)l{sc)1U zck$F!A70p#H;^>8t{=eqdP?0I$J^Y=@a~SEL@$ z>zM2t!?-@68_qRuvr#sJyby-%2%?#moz-RwtzRWT&xub2@P4K%P`*)A-7MB%VpuIB z+bJuRx`Dz6QsM(@%is)F1^Ic2+XGmK#HYf1r@o^AL#kKNwSgNo?iBrd1^bS-M^^~A zN`rn{(e4mD3#-923bjP>3s}uR^28~U&4#4~Z`%!_$Bj=fGLr9|{{Vo3=2MU}0=9eVBJePtf26#K_;$#h@lJOd&5SHv7 zCR}{O&&pm!2bj1RY0C3o#e*P)$d-9-S*A2ZsRMWj4WMLGk2~~CxcKTXR|p^g@c!Uf z3TQM!)@6@swKf>!D&nOr#BLZra8)pMEp477Qk0DjX^2x-7KMm#mgd`6Oi=K;TXEQ2 z^A`UAs8C_%Iv3(&jv#3XUDvsnO$QLC11{x4(pp6z$R5)9>U`L-R3tB*4a=*FShYZK zw&;olw?>2C`3zSDQIsK7s{cEy_(SpZJLjDI*@gFU-A}?klP=?py{l*4BLW9uq&O^rk z0LR={Am9E^%%+i8T|d}_z~Ei5#9Pd}2q@aWsqd&*SQ`GRh*0!4%cteR%9jOYk5&hD zS1%g{=b2_&xJ^dB7);`}1%@jCY$_gEl1#_Mb!ye^?TTx?E~ClZSuzt$I*MpY*1gm$ z*>6(l%UG2>E^1{mopCra0Tb+Y!bo2L&m21I-%&LKaj)mOv@nVfM-kYCjr8>`W@XKg zu1bKdMq*I-iUfWoCYRK@8uuL2Rn)s!>N#b3PwNJ1EcY!i938d!N7j^iiY}6eN4S-Y z>RsFUm_il?ID`Rksc4Ojj60l0WPs85AeA$h>pQ@h33#Z6ruhv_#lJ+g1XN*Xj^M3` zK)IuF0V%)`PV=uG2}Yrf7>R67h(Km|ZQ=;k25XNKO4rK{JM!WMya%FL>+m8^QYo1% zI$X+8Z)RpTTVU;YoFS^y+IOYCn8`?UX1^PU&0Nrb^n^S{M-||Wl;za5N}t>Xk-_mW zD?5+X*^tWU?swX9dv^GU=sfj#du1%eyy*7-0Fv;5wpH*%Yeqx=0B#B;o}c}=5aWWf z`ajrnZZ0Zfh;|>b<%m)TMhS}ju8(j)9vcrtN>DsPTR8x;KlvGN#{{*6@4G+K4{Ey( zCSBl&R1Xyk@lD>P6n;cdSX@LT3d*ioki>PhDt3{~WEh-hK?TTQaRe~HaT#*!ZGI#1 zbR3UyWHjZ9TBY|0`wXFR%i9j>3Py`&WCnX9bPJa1r-=6;z9+nl?R_w}hf@h7anb^E zkfX8LFYU9bniuX1RTkDe^A9%Tcng4+VxlTH27_}X<4_kFn6kJch;AIRrQp~_){%*- zKBnjj)-EAO`i_dvMrDl)(BX=>6Q%zn;nM#AsBX8LcM%S!f31fx>*ZO?I88QL%AKbGe z^xWntF@h~#x2{*yea zm2fh>(P@GRu)B#mYPT2WXW_a5iIM=%1PpL9iLtHdl++lcH=duAD3w*skSbru+UQeJ?!yOsv-6^RzIz;uTfw@SmB>A?a%oPhgk2mGt^&D(n#_Wrm65TJrH*;GPz+`P4xkgMYR146jn6( z3Tk$vcM*Yk9I&-eInLl^o7-_ve`p>B9O5Rgk!5ox+KWr0Y0_TNV0rU12n`!Cn}c{I zHC)PSRSM%R5ABJ)$`{~)3jl^(;zXNO3X5(lL--1_g zgxUFV>vJOMlpj{$gq5xbmHQuW)N{cG&(Dui*lWVk&_qfG>jDqHgm22l1J~YrfU@d% ziIoM~!IT$q6dfC16Fu*RXV}A{H{v0rmf=rqTnH2(51}8s?6xHc@JlXaV_qiNIy#ml z3KoA8aMLdkD_yem8>rJSOe(@6lOs0{RyCG#DBwnk9v#N^zQ`4=?osX@h;mSMQjmHI z+!oby%N4+Ixic$@(|kddnLga=5O^8>vB zZv-K*U9;GYqEqCGF`d-2++0eOOTo+pwyNZxA=RmAOBXGb4BdRN(z)hReU4yzW+6r? z$H$43HvkbUROre_UmD++Ld_Xj;Q<4kvyZt<7URdm`;^qi6n!*|V+2-ln^6ZlAXH2X zJ4^%nm#yJ<^%=d%w-J#zni#LTaq_?R0-_g|{{Ywch_++K^}Hh$(HFQ0{EUBAuouS+^kyl{-Oj`InUdo8dL*~4{t2Kg?dx;M##K|Pw0qN_UmhX&5#8Xz)#83*@Z4nbkX&R*=)LJ0V<+*_MXO7tIdEf%0afEURvU5s(MuC0Iu3(nBh%#JdDCkjyG$sp=O(wM=&DmDeUGbyt>U2@d0YfDL{n?~oPp zN=r5-7wRiW231%+vutw)ESD>HA1PH)mMyT~SirYECHc$P`j@V4gp2SF*nAe^#O}ie z^X6S0dc$7jt{waRv4I1s$FYxfny@{v0=dgi_X-6IZ|Og`F?T0nUY))o0l-$<{7L|d z@jV~2>SB_>aC$rQ42Gab&&!Ah53yDIWr7bZjbgdy=HP;!4~awb747hNh7%(c-}x}W zcH#(kyweaeMKqS(5U;{7A4?pFQce=EZo#VUTK&? zpmfG}d)peyIu{bevly3>l2MhWaX&e6d3l1N9;HCBe&q;0tY9oX6KGS}1HgGQ?{1=W zBHaX-0gj+57x6OH6C@7CHIX?lC)DQ!lZ7n{Ki9lHKHlD;&%IuD7sO7YJOC6@-B(GHug0A8h zVVlt!q$iZ_PbI=^A2DUA)C#-JGP8rS7Ock;KMw?~5OK0s3U+^!n*qE>Tur!#O^hj{ z;^kdab}aWIlRh>PuZZ=Pa)SIqgRjmQRg?`wA~r?UOp~*98|F^j&44?_M=;_K4{X>0 zXA(bnh64g&fXb91;iFCU)DqD3f5^?l!<#-MW=|@&`AxhN7RM9=z;pSF_yGf6iNhZ+ zZ~P&cHUaZI9%9BN<3HQxAYC3`{&gRWxLyf(0BxF;rLtweaD%j9w@ff8mhY>0B>_(r zF;S#iasL3Ahv^r~1X@FdqZJdyE~WTHVH``o{IQXaU+C?P$BggV{-qTM923_t)N1ew zeK9F$JSaV|+(!T~F{Nn5G4^kNX z>gE88?qb3FkFuwVmL?8}so5{KAyjdaR^9VimYw=#ED%xZxQ?nI?fFC*m0DOmDELh6 zpN28Fcp+6CxJuC#-9QS;;ASfFWC;7W3;w3#H-=g9Q1BIhkaR#oT^I++Dl>U5KT?k% z(`)#MmQvRcs%iy_nGVfkQtDOB^C&EwllTa7%h+ZA047c!Ev1uLyT$p5ji*8J4r0>_ zYP1ei1|Vjfcle07ydAw$L~YKvoj6A?h!AVA6!k5o$!0!QD&^o`mTlByEAzyokh&Hq zzy)UW0CiIE*#QDAsQtnO5Z)W8=8LYXQV1PfqD6C>m!6)oOC3X!(M1MY-`g+1I+)Ah z2Bx6_v^jjipcq3c54XXfd4-KwF%N8dh{VEfFX2U|?WMe5`x6B~5|!~C1rv5!JL*F_ z4sNU>s&U4@iEBaQB}S1)xC#(yy-ZP~$rKYDX)zohxbFT7DIs;-)k1N4n4nx-bO@Nj zB)nG2x=p)SQ)I_ds;Sumb{(`ux9jDAat{tJ08TDi$ULIjoE~viE|TL zin(yfX$F2XEj@Q>(Ftpkb^id{f?H_Cy?6+XCbNs9#28LwJ}Q6VEYU6y0lijyd5jY5 zIQx6?Ek+olD-pIGr{ZZpNW`}-l4D^SV|z zkc3>wSD8tEQKl2xWt8;>t9`=9(1Pg@Rc$&YlIf86NFup@BVm!u8swQQseY|sOu?Wo zfhHmy_rcc9ATd!xvpa<>FT`jeQ3@%(*fxh>aI)h2AVjy!W(2LrO+)52Rn5~Ys!Ple zEm+|e9y}yiKLcV|99M+5<||5hrcnWPlxX}!aBy=Ll%9bYha4`@Qji=jP)NWi6KDtd zEK8;^hq(K&+#ZPh3DVFaR6u!Qa7k5IqDoC@u<&LCv8~1S#xp^Hryl#8L1?o2hYMF( zeq)!RgUah0M2ui7!+#NUK|xgb9js``p>6W>?j}5s?7L;%j+%fRfmsY#0a$* z(f1TC&qe!-9K%*Gokj||lvmxsX6~H(%&S7-m-i@b-ooRV#~VHrz)8B4Kzv1I$D1O| z$CXc*kXL~5_brGwGam~uE`o|lct22n;o2W2Ie<9@!|@t}0|0-iU<#P8=zt}572H}l zfmbf3T-iiS5zSiR(TT(V0Ao>)sI;(jB)hHA#158OKXA;2 zIk#+nE#Pw$&rZmLgk98VZmTvEhRs3C;DF7(2&#hilTyp-UZh}rsC97OMCr_4N)a6@ zdSMG^tBtY?y6Otkfh!qNK$#%9XTH)kh%QX@uAtsc@s&P$du384mnS zjzBH&RILEUO8)@t3MHJ7{mWLd zS+yGH*v2FqX2^kVw<8`X9ty=_r7>fXe{#OjlYbJa!;r6n0u5rMd9ZCGa)r>@g0^`$ zingK3LPDVSnHNn1W8YCrhohnJ+-DiI7SAU_&33@_^;P7Eh+GtjzRUYn#Q`#-8Xv?bhI(cY z%gbzK0W@_g3R2Jz0LjzC)BA*cz-r>$kJ%d`!<_nvT1NF;4JoFuwfUBW_ojTnK~lx> z2{KMY-w_y8zk(tP&R6@1K=MHAI>f|r5ooAD2H@a^;URWaz{6gtwSw6-d;b7XB<#j= zEW4x{Y+2C?rt;Cm&Moei0UQK#7e%Z0xkU)#jr@_bM9N+}Wv$7_$eEYdz6ppM=xSqtabf$7+2FVhso}VWEMy(# z8nYv~#dJN4!xvu2@JRTUn7;0KP%hj508_XJn9Wfg;-({H*df$)39cXrq4NdJUFr^3 zc$Uz5EQ-~!#p-s~i2gPXBUVB60-#_+e~DEp>xh=_@n$3Dce8N^At~Dzwqddo!L!Zo4s)f|K)%wgNYwHj-sBa-FG8YuUTUF9(5^UsLLe}%y%s_r6 z#%7_yG3|I4i0!^mWg%mjp=oedL&gbC#sTZY{Y%CQ;C9OjUy5}qnxWWk4XTVYOW>63 zW$ei>0ulo{_VbP4PnaNV-_D3MNtGBOk=wpg3xp-&}KSV%>yj4FgUkoL5&5C>;B`*8B zcM+?V2^*UcD#x%!+%Ad(&0&s6T^t`1f#VFEfu;AWNDKDI4 zGa3W$b2}rFCu|nF)WEuJ9WlV5>gH@WLfbpH2@q2KOA?O>xqBm|fdY6`I?qFKE{nLuS;7DwWSSWA$@ix_9jkUYrbC?P0B<;_Y# zZnX>anbQr~_z0%wh1c^GD^Eqg6Kv+GDjCOy1|9;ZlD~1AST&2OO`v?_f}V+Y3{fq9 z<|u$Vvf#0sQr4vtK;1J6ikE9}Sd7Q)HgO|7~*=CDd-^IXQ3Jh zo+_YVA$dXIidxfm912xxe%_!y14FCx3>x})ls!#y`IhHrE!?1DW9`e~7>{qaK4a6T zLlE64mbFJ19Bhw|_FKMG(%0L}1EEhxv+QwYd0apGC^IaeM+$Fx71l(Tq%g%7;7@h3BAo`>xzohk;El=JkuU9FPK_2 zJQpwU>Wx>#wL;*oU}IqJu*>$MnYNikgM3XyFS8M0ss&0p`3d1>Lf3Ve6>a%j~1LT#qkFeXEn zlmqvzOc{c3E)%?Y14G-=fu;8skKDaRsr-JnnaJqH~&bQzlMRfJyJxcBYx>0?^w<(6-sOduc z=i+CJdlbZZ_Fe<#A{Q9Cjn3{AL(1yggXU6w)|gvxa2ou}gO6(JUSe*BSxzoKuP z?}%Zc@lkAZ@q`h-N~o*^_SB*@f@!hUOMszxj8bFF37KT0vdBu~8fkq>_r@855jJk6 z?lKjw#wp0Qgc)~v2J*}r_f|3M1msbvj{$JGsN148lz_Sg3R(GA~2*I8T#Tb>Ei}Z z?lY%DIa%gk^v!TlRP7Nm3d%Od25DpmP&PZ1f{t9Wzozi8)e~gd>Oq%ry8i$^A}SH) zo_{fI*E)6g7T0#^8iNNL^z+zogU4p-E?H@@Naj@0oiK0M5_`4=f6uI^YE zrR2FmqCwZu*L%3Q7w;vsX_K60$2}3=2zlmq#lTCl%&!6hSdYa)CKg! zRBNcv8u~LRv6im!RU+2n(!%&MK~WDvu@}DR-Qs8j^fv)ty`iW^JRsYr)l7!pjmD({ zC9&vzadd2TWnacyH|;JA4M)O%y-nJTU3#(xs3z;C!(G)(vTmdRI)T;YCg zfj0$a%le2B9zp%gkUJ}p)Lek}+-h}VviKGh;Zz2DWLG|+d>vxczA8+`5K)I1f4OAf za-SZqGw z3aWKi2+{`M658-(?pH&AY9yYP$Eew8O4Uwr2Hi&@9SwLR{y7p}zEO*`q%GC-NF!HQ zS5cUcE+E_jaz^F!!vtYzyISrz7Sjbve4r|-JQ3*^+lgr&-9S6VG#=UIpD?M<#I&V4 zxVwE#%rq&*tVYW0@JJN~dkAN$yCb=wJhny$KzrsmvN~o_8nsGe6;SDjRELvuG-C2< zT!iL3mZ|y}*exi~KqpA_1kQ4H)LaD)K_m7lyJ{#cdog7c*;tIwtmY6E&RHd`ca@oN z)mBf;K<2=L{6c`=f+WBzx~Pgm<{{!Vq$;ou<-%EtG(gT)Ex{SxbUeJ0+OGNk040D^ zeV_p@N5n-9t8OdQMzG+kOWNLYTri^LN+nCGa6-tcxGqq3#=Di6qy+aY(li>4tS^h) zG!|Z*%2SQ0)S@#>kX_#Q6Qd>XaiCuE6)Y$Z1DLVW%dxqbMnU3h&jZXl0}h8!N(52> zQ@9{g^$G!?h!i)HzfpAqW2j_`n_eYA;NvFd#dx8wn0_TMfiHntNT_hi_x?xK-X35G zA%(jd{L1A##1_|uxo#r!MMBK2-ZB0I8pLpg7sMeQ{7Rh1xP&}ovI=6|-xAwURb9ji zTj+%|MfDQ3CQb;!!WCQu^ZA1otL2=5b#b#}@d;2zvJ&k@a5;s)-8NbTvy{gXHAOpx z7{|;RN@;){_X-qRTxAh0z8qW-5pHXUil{}+7g`u1)f;z~5wLJMCU+ZSsdGB)%vW`s z>Y)IvU7Cl;93fgo<04cs8ni~XIlf?ms=27k5M^9TPD%cd(I>Q%PIz9@RG$X-F`5%= z1!9fxfWb|#QMON-tK7Oy4DJotvU2y)G7!Z4A5xeB_B4=4)p~qN#_feu67u5OR3>V5 z159~r4D$%%363raGq`EoFNO9lVMKbVQA*wb%tK2KMO1GEIvx9hs9atN~#0O)oaiF)3kyQ!ZKq7V!Cc2a#9}QtQdBAKp;Je= z_*vpwHiWVSRTUgcf{naxIYr`fQ010qs}2P!p9LH2{{UqsB4Xy8yqkohBIYl>U$qytiS?idZ0P-zjWi`b$E^ehZFHb4cJEW~@vY_`1S66^NtHUvI0)-2}b`>lM@oHCsjZ{G& zD&uQDK^V9J?c6Q27a49A%YKoK3%>3(fWILfu=3KSOwjCy?kQBzDsmIk5EY-8Eu=3~ zPFF)7B5Mq}Ezn|M`n=uC#VfnHOHhPsH=N=aWL@VGTspiPAct(-$0Ex(vQ{*#u4A|y zTwvdsaE+<;nA*az&LMpzbjEOlHw_48ys+)T*Allv?MUiJo$hTa;B_lm+~H8l1LDN$ zCFF)GIS!y4H)V=O9y1|U4X#kQH%15vI68|0&UsX(KrbTwGT#C+BY!XqMN2GBrOQRS z>3f$d_Fmz#)7@qcHwt=_jgH^gN{mj*m{xs+xeKzgs_`=CwaWJuQ6O4XznGE8DZ~UE zS5UEu)0SlB8Z^rP0OL_}QP%0|D`Ls9XCgdZ@g|TqfshPVuSnza&+c9Vi6*uiU zs+eomUCWphC_F`~xB*o*ZaaV(4{RZk@WCCTc$Pt9lZog=8T*#7I=fhzp&aEg01RjP zMif|cq@f}A1*r8%hq?h}o}gL#BrS?Wq(0)qw1LeKW)yan5E8SQ?mnMv5L!+5ku53C z!GKYG@f%??%PN2`IF7iWN#P49hZ~{JBwFIC17<%XoN;-X}*B1j6wa<&J_Lq;ZmaqlP5q zI4WXZJY<2}5FixDp?Zj{8G>9671SOH+gp?lqjiaQDdfzps}s}&xOgAjvV^-uC8ueB zWV+y844$EPu-ay5_{7v&A#ufw&Yp2esKtifptinEK?o_x;%H;V>J6i2moYVa3%Pr* zeC5#s+cR-#CMz(V5M<7!EEfkC8KNrul9Hh2!-zDecH9+BYde5R9bNt<+NsjB;#@@< zVm&H7OQ=Qba55%fk(z7Fz&dRaD87zi%$|FM30D-{A|TZom|2a}iAe!OXr{-Wq@MHSf?sbkk;QxnI+278q&BbrQGL>%!nv(mZ&%3sP@I< zD6!n&lq@BCjY5Fx2S%Z23wxV!9{WTCOx;Fd)6{NN`<2W~Fm4@p5RMJ#is*Jy!jg?k zZv<|S<(J}nGT^Y%Hp(`~mziMzdTLm%tGMbvGRvBIbqy)v;u^&3wpV0XXv&i(?gd3G zz_FV5U}}pt$2H&(qkk|}cR4XniK|`O$^sZ@ZfeVLx`)vAj>WqmH^ngk2B&sQc`)RG zf*A{QYUjkz73DcJ>Q&e| z2~$wmjJCGd5wP>yiIS&+TkM?U4h8V&h5RJjiCilaJ4?#1!wLYiG$?zWsMWfa3M5}e ze82?yraT9dZ-@$F@Hd-a+(RXKg&2tc0BjrQ^Bb*8Rv3It8N_(DZDQ!pz(whf1X;!K z#_>iF2~&G9a{%F{UV~;)B`dMxi-NPdzedZ9Hr$bD$M0G zLx4k7Zp)RejOF}Y!Xa6sL>oV{;7*<{ENQ*QumMhud5fL|ARAW@7^9XcM$?&~jd+_+ z;TJ9|r-o=P*5#3WC7251%x#r=txVO|#7&^^Fu{$&tj=P-8C)a8P)gJWz%RreH%sXO z8o3x1&^29=qTTGZ0w|{j6IJUNjzAj~xaz=*fF;f*IwOrh23`ToNC9;BGx$}M;$sq> z3^uDj1Ur*Vp68}^V;I(#u?yM)(jWk=Vlp7|E-IrsrfYG*8s>f_0Dy1=4Poir?JnwK zRh$fMG1g%X4Di3i3Mi-Q4gtQ1WRUJtLN;n~ZYOLlQkZF(8c)h$4ESK31H_<-B8kx% zwE2j}Do_O>n5{!NShNkX;7)_MN_Y{MH)q^HrIOS!ge-E!EHQb5xleN?gRM*O(rY&w z{{Rq(KrakLfI7rm=1~^2Fl_A`0=U4;?<8vY_$BqB(;t8nL|sJj6}+zV1R0L^)g>c?{B+vN~z z1DR!FN03}lqQopn;Ru+m9!OCa)`-T3pxkJspp|iUF*1k9L(6ZOd6B-i1!?+?V9!~O z1%4nkEpVRZ0jrd7(cBqNE$Uv{04R&xvcMOt<~POQGsN)-Z=^Ys8hhhN)Ne)VdgMl2NODv47O2BHxW?HiG52! zh$SGG_W}u1#97u$Hx&0Mj@!+|bY;8Da1IvBK-t7X5tMjk$f4tzfG?y54EEGcT06`j zLitN!Y1qbq#guA+WLmAV5+d2UhyeH@^OfF6EitG)H1;kTKwi#f%Y5OTa`zSxu5+!9h(sepsLpb41Zl?hci zdDAgC{-fegh_qyTfhe`=q6?_-BN1FZID}St3nLb+_X!1}R7Z%|;518x;39yHuW={} zWk>XC7_(i%X1NSpZi+6|(hCIQIP3ksxuiR7-&k$oy^(YWhB(yJx#I5SdQBc8s z*hd9PxW%C|580X9JV2;pO-coz@-g{-(wy1)k3x%O7**47;FKAHOO6$TYzMK7EnO1< zmo+e0965~W@-npU--uoy^?Xer`vma;!doOHl(4cl%goyZCX#Z>uc@vg$*v%)NJB3U z+F8^Ul9!opNc({y5ymC93VcMesr!ej%k{1NR4ZJYj z2p9#p5v>B7j}=SF9!x-lW$sfJV?5rYOeR<^^HEuo>Ro$o79=FO0(TotYX?lO(vwgR zF$HOr2XBP_s+ZDY48W4O7uzz@!ObyNbHu2R)}obidz7{;I2g2LA?%?FL5G$#Z9T&f z$Qc5?!I4He(1o+lm}PD9!3l>9Dm)|w+3jvTKt5%AFA&xj)ZxMR6q#R81#QG(6MWnj z{HPmY-Lq~6DqSeJfJF$qy+pY}qMiJZ3s>R*({GH#kUKLns^}&6`Je*n)JeF1GdrKQ zIExaz-eC$i#9pPii5fyBjKWr&9wlUFguZ~6J`ixp7$W?+VucIPe{!Y9f+yB-olMb} zCj=ma6^T@E$Su8_*iJeSQ_B_h8daS$!d5J9f0 zI?ch2$xKJPTXDkG>JAIi%q|e1vg?^O_&bHh(Vyn z5^2OO+FYXKMq&|&iVJeUvh^{qqnUP<`JCHY%zJ+2sBHn=yNaL=DpQEMVgU}+%nWrZ zYmx#EpAz;B{ma6``zwi*ONJK^bNfKh-Qr->?_z?JYjF@%`j*}$(HAvNh`=l!A~l(m zLfY=;*iD;68KX*a)D4CuUZDqN$l_RWERNl=28-e`klx6~ z0q|4{oxNO4ww=JQ$*8~=u*Cf8C2CRgE!$m9VDP0-b`j0!w5-gA!30{Q28-y*v9q`# zc}!sWCmEk{&E8{$;(kVV{7_g%oxvn9^%lYJAx|RiM&oi?HR1lNG^DMw7;fSgm=`xjim0P-sB-{qgdWKLB%xWbiKwPN2 zJVP`&NQGWzWkgrtj;+UubdA2_9Cys5`i5k?UU38!j`I#O-TwfDOr<4PKH<@|p&YT+ z?U{Co5(R|m#mpxPSZl#4hz@g!dj;+_3z&J-X#h@gMTPUeKM+iV+z&N8kQP{IQc6lV zmn=Tu`On+|Kz5E|-$-KO(!aP7iZckTDvEu|AltTB1x~6FtC+Y{`HWKUlyyy%9*n#Z zP%sdqlyYWP_bfmRVl>^jZ|p>ca2SI2z%>ioUZWH%nDT;+S2D7JY$a{rn0EZbr0Sqy zq<3d^ zy%rL-BZ&OYm;p_UI2PVWfQxy!RuJ(rWWN(c50W)UK4G;xkArfUT04mBgI!*rIomRW zM1HF~i)4Mo*cPCi)8;u!Jj7$VJB_U?b-2=#%|WW)YRp_*@M2J3oX#17hSm6%1=5vN zc$+1cWJz(}Vy$3O{Y=Yys>CT;0Uw& zK`zJ4ZIakmk|Ad#Vae)U+ft79d6vS%ZxGtyu-(V*);YTo`T%&RFa<_ZGqZ^H)zkv@ zK^CR1OmOZsQAujJkwqL!YA}gR_cTmEK`i2XB=7Sr!n=@0%O!;>Uq;J_?V93&`Hc2z zTn$Uja}ksHn%xWBMRtYFi>O*H5VlMA6tIWfc*zJ2CMg(Ws0$Rd00Zg~vm9J=`3#{8 zqr5s9mRANsB8?3Ywi8^Yvg#v++%rP_$6%`UIKad)l-zpqlBHN;8!6>rn_CE%xD^t;kr|FUgtp73vp^RZ-~v!JPLtQoz8X5cpflXB2p@e$N8 zgXkh4Esk)rcG3{a{lvm9IAmVq;iN^v=6&UeWt0j$MiVlYM1yNDhzi?`v1(8!Z~(#L zEUaLu#LCuTl^?hWhr~nQ%)OFEW(R~~;^UnYK?t&=t7YY%cNf{Hg~Q4W737=QzvKcGFrGTT0F`jESJ!IK=Ni#;P?muKqJE$iF~6_w`aMDseI-k zYVTJl$J|Eloe*~{R?cE9VD&03h0E<2a*qE1h!rh^DYCO71%>d70G0zAyZ->0T}b4a z;DP|rF=7~q(;g){a_%w!9o#}@pNX>K`i9-tOBjfCL>57J!5WSb!41JoEd&O&nP+s% z1+K^f+lte2*I^}|L)=-B_-01eWMvGwY5}JbqQi3elCx1(0Ujl$RIoD|FVyGd)xyrq zS#3N*jXvRkjRM#x!1EBT52z~X(#wKc=3b#;ooL1)7k3mw(4qnajrBb5@ubTuz9+yR zQoxjSK^m)I4b+y_9($R`+Y*2V$(6PESY^~yvMLEDS-6#$Ig29dW?L>47$SMTBeuAT zia>zWQ!=1{2QeB~Jw!|h2QQeJDVR^hNV8B|w&0m=8KA`MLa^ZO6ksD&G}N)<+&{$t zMX(`Cvg!l1!~mz_Eh(NVAnQ@SOwCfKQ5;s~_-&7IZqw8h7s8_<{6K=`pyMzJLh4YC zmbgX-)C*@bDkJVzTTa$#T8QgKxnx|-qHZKLN2v54nAI|c-PgJPDlHs5z{5UbSPzC$ z;+|qghsg(lQ*6F+FgQ8AkzmT=6E@5p7qr5W^8f^E#JE#b&_%GFq+OD`CAdCU9IFNu zwp!|5Hlh_Sw&My1sHOAFzg(=+m;w1p0Up5>CjjU0-=8@qtwFsIykN}x2TfVg8yCcp*5b@eVwaG*3AjiArC zEx>bk4_CN^T-3$FB-+Voi{@SuE-$c_QBY*BiIejM5l->uWwo&ZdxHXK{lc6W(`Q{ltR&2=#Zu)^K@5ISBpZc{0K79e)YTVP5p9c& z0a%@F8VQ@ls7{OK324XQU9%i?a{|MXGNo6ES$X-D`9-YE!}ysHFQ6Vjk%^-uTR0xGs zR+6ai>-72lzJLGTy4U;levQZLIbW~m>-~Q9_s!o0$OkQdx62TSuC6cy27y3mA2ZRYmgQ2#fq2hs1Gf~knQT^?La6qX3yN;NkBtRI@W3}Z9B!_ zc8J80NoF|-Y%@aOZZJi=a4kzOx z`M{`=Ad_gy6AeZbE|!JkW&Zm!7$zDLaqG|B@w`ManX59cF$`~cHRQqpOGl$e0x%qf z1i;ZibglFxg*F5rNXEHS10jN70Hb%klO9u=^(}kLPsUS-k6{x7ED^!rpsgI}1a1_7 zNuKb$qdOqTRC>%;9`#QS!xT8pq4Dax>UZwvc*b$KC`()E#1CDzrS87AX-B3vVRiMUA6|A^?LBnp-f?s;NFT%z7U1iq{Y zNCNOMse8n}bY5NAnix-b?JyYY7zI6&8KCe0l0la844U&$h8i>@gF=8~NEEKl6Vn`s z)wk|7!Z+ehI);-?|Ir9~+&{v=K&Ww%7zl-4DA`amQo1D3BvC{7+3&`lpE8X;vZB>1 zpLVWC*NI*sLU3k!IzTRD6A0|TA@5TL1^|5ES^9|AL}Asar+a~lK0BXA1nvaMKf3B+ zej-h50DoUZSf?ZsNCxx}rHAGxndpE{7}(yOc{ z^IxQI4EXZwazkB~OIgAojM9t_7&#afG4E>$`0K9FS_J#vM?aZEDHJ@lb?IkMTjQ_7YXRQ zPZ?!G7~NAaP%73nc+UGvct=^35H1Q5UaC|Vurp8=B}(zUmoAGHhOe3v$6mei4VZQ; z!QF>Yf!T~oh#z)N9jeC=nOoCA#2TDs|{F2&@Y7uRTs5Fb*yt zcOU?<0b5zsX|Q&sbyZDq*SDhX>mGN`5}sJ>7q!0|FpaKyEa@>Z&h)=gQmpGZ(tE-FmMuyTE2WlBaCwt&Lnw*35OX zkW8*w^e|bk8q5ciR+H!fo6&p;Bi$R4(>FyE7W~@AH4J9Ox>EDIloTI5^Il&@m1Z<4 z_6IhU{kb_7F&m@$`u#!0Y{u_XdvkjBg)O&*!MMRWmDZ$6h=5^Ekub!Bin-g0`hqM= zynH(URM+&)WJl)-;i=EO&-l@wMZYSVm&UDqQlpZ6wLN{K#=hj>FJ$HN%R75JsV&Vf zm+R*bN#B<9+?G^gxp`MU9@MPO$*1ibsR++WXq2Y%PWHVX+&xhE{XR%VWODvYjmF5E zak_N5&((#frc0~GDuMF#c%p}+ZHc%f=J32*4uNn<3x)mH7^jPab$#w*0goxoKSbX>T@lS50lnr(*2x zEj#D^roAoIpQ8tbzPlU;w{FZCCyE|Elo-63x?{fm?#mC3gTiVx-N9|!*s%crpoyK| zdl&6nHYR3*UJf_EG^$|BSqsj`2Up8tiiGJxevQe;kd+)LnL}4Ze>UqSv#Z6X**?9U-M2qBy`z<3po@hK1U_7_AvTyIZ^&<7#?Y|I-9kz=4 z`QJu&=SI2?Z&hr!x;^{JYKwtr7L~+J@c#OBBYIryRb(Ff2lsblqBtb_6{%6)S0}gt zhVFSl?^}&YF);~l^T0PY$_+y1l*lSvVs_?^sfjOxCAFB3^n@ zAVcx3K+@1VsZs;H)Jt==r;ko-d|FX>zw-Ia4P*YD1^*BGM*csxlH5Qp=6udUN5bLZQtG>sQ>>$f3u&qyXzM^R) ztD>nQbYk6gFW`6HNBcU)h}K$F{dLBeC)KKAzwvvozr-f(kN&DCWK6CoHqO}B`c=PT z{>fvd>({S+*}Iqjgev>KM|G=AZg{*u-+rfS(`(wE^QT7losgd0Sn_`zajNvTqEVX>m z=#@t8C#6?T<%@ZxnM#e1UODBZ&9cm>D!=MyuMbH0NrynQ>Jr+!|yJM|;L?0tv( z4?DK0ywCOKjHW@UV<*^JV&z`aWUJU1e0iSwf|(5d!fJWVb292N zR-K7D&Z3%mpi-0AB}}YVlMR@@R%Kl9^4yp4omW{LGFLCiqQtb4OL-!M=!IuoJXnXN z@xxHDz6oHN(z2Mce~FF=uR&yAS&S~qOv9kljF?~2R~9>5ka&IR=WW$14L|+1e!e`H5}~ulW@&u+CU^mcMzHpx(#i_W`$(E>pf3Iqt4Tu=LZ0MfLk_CM5Vlpp`^UD zp)|e?(24-Y0YG95BIAk?I-+sKC^LFwkt&bP_wn22Et@we40)OZvCDPKdds!VQZ#_? z14sY|WGLMF0+gW`0Er(0urdf~>v&-eGrGPam@p&QhKeI0R5a93TCho{2K!D*yZ|<^ zG|W&W3X9>9lv2M$Fk#`9mLc+Kc;|r4DU6B=LUoM#FXUs#6jzGDz7=zs<;iQND+N{Q zKEl4ojJnU}bkwP9m8fuf6BQxhJCX%9g<<}@XZ+=U_piJwK&>M0hOyi+D86_*KQMfs zU0AglXOb7j;!iCjtlAT#knH{lZaz;Wot-2`=RLCcM3*^Y>AxryZ;}_uf|<0=>&{jf zm~t~s@}I~oHXln?)XR>(k%u$My$BvV>!(KS6dp48XREAJ~NtxXi1ho86D*Wje4-44d=n{)6@U1boXk5SX<_{gDYS?2NLnAH@yP)I#< zSuct4ftt;k$?A34+YGqHP&$?yxy0Bq9%*_y@AePS;@@ul(I*san4WH0JufRZE6_E| zFE($Z%goh2FJxA@zS8qdkaeX)&9bl?^MezWgj*#-cI3@757jx6A0n=b?7I0jF=dKa z_&Md#De*8ZBnw*r5WUO-z3d`%#1GC-4$m-ndGXI{wBCSyI+<8_EY{3JA6GY2c=y$H zFRxNchgU~^;(JA|3Ezk^cYjZK6mVNhyDmRvue&|3J35#62si&o<#mtWkZK4bshrM5 zr%|CZ5Fsi7ffu`tqnQD?mVM0n6BFqy_xcQpL&Ah<9o3Dq*3y&c z8s!szF1(O_v70mhT{y2o=rQv(ynUhB*4j`&#$K+D!=`lU$KmeRY>q}T!kd~O6%F-E zoH#%3E4)xsu;9*@>Yc~iUoBYXA=Q#4N zpS)-8o)}(W?crFWp+zY0e_r7A-k3#$7W-hh%g}3(s*vSvlIwZ2Y!%we<>H+GL9a!! zUU^BDsVVxtq5;M^fG01cjy}_!nLp^&`Kvc4*WL~!BZvj=CuP!od~WE6qC=CVWN!!$ zBpWrl6`M3P6$~jJC%DO&6$iY&8H3)9c*ic!QGBkt)Lnn@r_;iehr3*i<3PsTmav7J z)|V3-T|bq}Wc7l=^OzT9JrhblM?|&MK2#Ps283+m*B%P zr;~kIIWnx_hLf4F&Xc^owG)3KDompSzG;2UVgX&_UFhV`U;Z5To$G^!mi?ZI^0?n^ zE`CiE$;ElMbe?yvi&F#h*rax%`_#eHihlRId>5Ye9fTP#;bm4qpW;(zp|}AS?D+HZ zp0NhMG#WpK(w%%k6h@jR0UxFKW1V%GWszm+xgwlN`IjEk?o&iyZ=rNZIu;QN9u^T3 zx+(Wix+%Kxa?2uFnHO<=L=msF73`D3aMX0N+%D^CLmLlg$x&cNRUAHTMDH)}JQ3xag zTodqM0VXos1|*qyynwo>&1K-o%aVot3-q4UlinxV*7Ygs0ry*`xNM=2c~bGmWJTk# zUZ^v)NF89mFC#Rgl8Of`K7$4W{(_~dHZF8508^4Bz<2SLQx{2jX7i8J=wc*`*9sMD z?)yBiwEn!bn8m?R4z4K8RG1=FkA;XoFK$R;H~PLw8md=>+V!ns-&@pKDUQ7y3{zia zh{FTpjLC1iTMu5$LU7B}hEKoT%2!;g$(#t2EiQjMW#Yo2{gvb8i%2WX(6g0t-P}vk z3-4vvJmMwu7N4f5{&wnIQMj0w$XOZf@9v=-7l%2B^|wv04gb+0yqNt>Z*Kh%vK4%K z@!l$(i`zC*fpf;5sd2q0%E@6)AQV3L$|TA~rTMEDjw3JAtL^rQnS0f-(sJs0PW<6XxIbFJf-=Bg+h8f?yk21Z;g-5Yq{ErLceSWY zAlVIy3J!}5U4~=sYt-D~O5J` zv(m;g-GF`WG@&-u-BW8_N~cj(zSO}Df% zSbdHayoe5Ba9*ZqmmWI@OIy|=i#<3i)5F(rgUIUX?CnoRM(I9)og*ScpZA_mJhgs~ zxWe8SpJ*W-pUM_Ajtk9r7o8$;jcK1vZ!@4dhlt4>B?)6KWwUi`q?-4vR(hnOo!I{+ zs${;1yfxmfHJemjpIh%e9yk}(O(%@T=;VD4R`Gdd%6p30C~@^tb_!qmzB%9v!$evB zq5nk+6xNs^6uwL()v=en|1m}VkEvf%D=nUvdjg5Goc7hqGaFv@w@Lo6szGJn^lU`* zuZw=OHBO29$nfb&AX7Z)|C9&Pa_|E1{K0fMF{)INsV>C3B zS3=;Tgf>_yBs1X>hR4)_MpD|u2c`ai=zZTTKDV;{zvzZm4MaDNzLz(v-w4=!Wr|_& zeA>Nen3~xH70u>&SmB~3vsEklOO@I;qNTs2*rp|I#%WcKud8gN@marOdioVfrDMZS z2d)vt{1!OBo#AO%4#_xXG!Q*nqr|ASGsl{hFe7F0E*o%*y5azf&gVV32Fuf&%frVsgLsbVtyXP4(QS&n&w4q~f#zhgeSPA$(}@J- zLd}&>YtaVOQg-hUjN3!X)Ax96=x~9>6~ubu4NLoI?x8aR*#rJm27j`=H{DxU=yC0f z)FvubL!{M*2Ny0EIi=RaHQ2v~s;)Vm*rO3Zb)HToe-26^S+!-HcyN8ktXV07&iMj< zm``*VA39Xc!fHL~7EsE|FQ#D+Ato_A108+k^8=_S+4N<`1yHDW4nH>}vF=YZKHA7k2G zMfNdVgL>k{M7yViU5dpvR`Z*K0M$&IOOSa>e8G&`)?XYRvpB_>r}Po;1%vhSDE z{okCoEQ#4Zi}ejzDK|aWOBQVt4HK^>vxJ@z$6j;}tynKe4jX*!V(xO@CD}2oe=6`* zAFx^xBm{)w)KoOU%OL+nY#4o^Wai^ZdLo(!iM+%M&oMOeR%qSBQo=o zAiF^aDsyN*qQ{#g2qU7Bu!qIMv|FVCOfV_(UMX*HQ+-U>KYmn9DOCTcKNb^AbfYG2bpr*@}~}?*6$8gj_x6|qvzu#j^E)3mVe9L<}pRO=Sbd8yBmpsv4#pf^gf{NZ8i63 zdoG>Wzn-}66QOK#>M^IUNt8H7Mth8AXS&ME#YL`fgVa&P7pkMRRoKq;QCX^UACa8< zB62v2-UrrI8G5N&x}i0vtn7T7`F4~-8G+#NxxlO;Mci7JyYlu)VM2k)~ z+AWN5o1_ic+tR1RUpi#Lp5@|bcSJCb5k%Tw-(Su@nH`1Y;!Z8d9Wpxk!!6pBl_k&V z%`_^LHY|pTWu26Xg%Kj0tnfr+@R)CP_{(aw60=C5yTR3@H`zUANsSj=x63*ln3&F{ z5jfN|bUeP|3-*tNX4nkJ$BlOwRz1zOz$+NcHQVr~CKYP<1r^S5WSE7UZKS2QwioN! zFO2^A^!qP_zOMeIRT$d~?v9kFBipTQ-(GrEcr94a3^~4}eZ1A&x?mutTbu0puJHW< z!oq5NbIrKrm*X!x9i`-V8-6E|Z*5!64u8Ad5E1A7$-Q*r&d|$;%F6l?2aII1^Ve81 zYZKy2-Sn5~227zY9PLpeZ?YCH=yz;*1}7CrycPObrP{3}nS{5kqWg+Z8t>MX@_|Pu z5I?;az$yyuK3CS+{9t;4b1rUYR;yb`2UGv;Syp$tS4oud9NP8nf;n2;fJMD(e11|x z_M5C4Z-wBzHj901!&s9?pWfqpMG=g7ReQHjtjz9;X?{RP&rIaC((GM&O(z(B7(Pr= ztlcnNs%uSg z@2EutlE5mQ#TeU63=)F+u=9mk5crb4OQWvc^-lX?6zh8!W7Q~3^!s^{iS6B=?wN%z zYB`yhR8~2A8gk5U)VyO5cNvi>IakTDvIX&2L^kQFlt7-UIx;YN6Iu8?R_aCEs_fqP zhT(Gihp#`Fx+FL*P>U7_ORzn0yi;jmVIdH;B~6F#Bf>knIV{*z&oM@6{o3QYprgOI zWa65*w||R^WS^gApeB9T9ZqzRjO5+rl{+8aO`FB{-N%xj-GBC3=U7jjBJUm50_GiHN_6WHKz(ooN;^-EK@h}WWRgvnos zwr-vqUcX9hfuyDI;r*_Z+!HY=fzXn3zs(ysCf>vEE@5$fe<8fyvs@oqX{Vbw24YI~ z7O>Nka*|E9O33uvTUJ7Ibx6`+9!pD^9cNgSH}y(T9fwJsp7h>y9C%P_tfsWdw4xpB4qdBlpb#lojK2AAB3*CCk` z?K%T9PU3pKPit=}Az5X6$5&dOg$h0tn+Pnt0lX+>-8AyElW67@_c_0&-H4N`@l3a= zxmHvo*7fI9I`45pU8i>lS(Y#4d&@uaL^4Rr;=J@P!YOgZd(Vkv6taT$$F)H`Q!_crD!e-Ob?~zzN zF3EKPubN)@B-O5P0uM}uzKX{~Xv?i8PzAxK_Qvxk`_nJh-WMR5b#ETO*j3$o)F_US zTKKVALGUJS7`K=%EKSoRS4r(qZldYXm;om22!Q30fGqK0O>=r+$R!qVOVHMXu@ znbVUdtn}#NVpu^|^$S10&Y+7?QhW15_KZa#xg&Ho`BK8xC*h&|(OHOH(Yy)`kI~3H z2d9TxztKuaZ=QGe|0ptjVv?>%r{awo>b>qNLOih$p+boOV_hWrTf?BV^U*dL%|OOiW|#KGQH8VVVo}ECNuaADV)F`G13hhNjh?I{v6>O;%>s&~SoB z=$QrYuwP|1=C6eG>{yzG^u!*E8Zy|nm*;-nDaT?RV-|a%0;(1b4F${BBkfo=Q?B(1 zbYG47fdRI}(*8taWK^^ruFOXaf=RgQY)ipw`o?nEceXDRij;G)*Ly4)gWZYYvU&AH zOXRFGPGLj!M1MhR@Y&`!^1QQcVJ%G`tIxre;g(5!_g3~7$`LDi&(gm>b-Qthcu;pK zMCIBr!hUqF{kO)fpSk_6&>6JX0bcgciSIgr8S+c#W}@Va8$6v_Wy&bEYJ28h6>kt2Qtg>>E-nnXbrH%^u+X#DVCQcVc z!k+hty*QD1vhSu3Pt{*&@JZXO5D$;GhZ9xwoqs~J*{8cy z^0Z==i~WJ#BuSw~?ACD^Ud@czJad46tGH9lN2wi`2U1cEB#%!ZtSjbn;rbQ(8@amfg2t3ZOjAMu+YxBI7mgV_22ciRN_H^c>1A`}zb>M1=5nymSV2FJbP$s1ulY ztK*{9j<~qc`2yf&p%U~N6s~>lpyi*7ryF}tw-{}V{)OZ&a&!-~f;Gg(>{BXBfw&i) z*(UIefbpaPae$Fj&@CRBkaS1vPuQCkl{HtFh2IMlbqM*tvjI18A@I-)`hcvso1PtP zg_+!PtY+n$$Ye(<8wSiNj3K9n zQv7lokod1t59s-i0C5Vo+2ynp6fDC-SliIuo+fP#QnC^YJ?HeKajjnJF2mrG`A9{-dCNEFiVNySs3 zK2ZQ|-kBvew1fhaF-v{e56(euC>Fk30P8N07^M)jIZBUam~PN(qo8|uLBE^rUe4R; zJ;!!m@F?V?f206PrI3D9$H$~*aiKf+z!vl9G$PoNLLkTiah6U7+yqo|9x9nQg6u>< zI--3(*#x|1aUgN1^v>N_p1V`{UY2Bk)o<#~%_p1_vC50~EiE9 zBsNLArwh-@za`qU28wrFsT-7k?oy z|3c<|+Wwrq^K;IBVnliStl0KNWuM{4e!U}}+iw*X9!X9Zf(hSmf*?1c>o=uaWyT=c z!MG-x5)m{pQrQ_T84SaOjVN?}zn9(cJ z?(k~Q%xi(+J5OKhPz_Qbp)7bE8)KoGTQ;txort@9~?VknuYhW8=mBJI6i)k6!@C{OY0OY7b>J8_ajV_ z$N*tLLWl(IcwJ312RyrmCKaUZm@x$6eIG&%ll{Op;d@^@4?k%dnx>UM3!(CAsnm}4 z0m9>y)I=Hz+Byh)kqQ!cc$Qj{@`#?v*U|5HR`zGBS1i~qSvz>5Tf)%y4 zYm=sTIHq*4et&$FdN$9H&(a6UAlW5+-zJk0ce?`;ii2S8hne)P#W5Xcnm-dGu)@b9 z<)-l$625w7oI6au>!rp6*qZVp6Ah;s5|ZlOHAXlV20lf5cR-mgYEASiOKG2i#>FOH z6Uhu3gLE=Lz|pT@q&gJbbifY+IYkb$thjLJFE|ei--f9}5Drj?Ixr|o9e67T4*WtK zO_0H`qqn65Dk>;a9m2r(uNv6~&UP{EVSoH$@}$P1 zF2NPc9sLN50|`U;Ed~e>1PwSaCfNtMDi_qrktKF#xpKUNrK5F3`Lps?Cj%y!0S|$& z?|muX?pE*~PeTq*|DNz@LG!AQ_b1E5*{Km9#Ps9yIemKPY-BkN@uP$e7XD+@JzNhk zF=yUO9FO&Woeni0EQ`}UsYDPoH)I*Jaby6Z@~h5=tSp-k1_l@^!ppqF$Y+%-niglSs$&a#apbr&v=5mspk@rgA+jC7h61V^&iK*L3) z)p1dL&#rzQX_We+#JhwE!A!J?>MhrC6;2yVC%*jEsekobK;YJQ*WQCQh98+!adfzn zUb2E<*xG%_A`IWICD{h0Ifh@E&}W#ZR}h4xF5CJq!dP{>!(J4Uzj(F2w|8)$LLwh1 zqx3$TTO$`DMMK|9KJSE8>cB?n7$iy3T$_>M%M5x1rc0qYj_oW|qyBQ%ipgD2+Mtg$ z3gJvhpEg>=Bg25ylM!7^D6Xei4fT_0( z#Jh(yRE}C|O4vgum(xBTCwPaY1+gC?5>vtxu#`>%DPY$?|4|P)f8^ItBk^Xp#I-~g zM}BY3JyTFwK(Od)opWiY<+RKs)Y3H%#;$J<`qjLHV272r43#w^WxHBuJ-HbkEi zw0H)m#K*f&PA~@c-ahu5Ed0XoTuM;92E+vRvCLp+gZ)ywiOB?sLHmScH6!MJ44znvS@)#;`w?qHq4SE=}q2j7UjMW(z)kkV33g(=g`!X z`erv$E%6r*v(!(Fj^B<+RtzcPVR8!ob-w~p8E})lF38d~x2lILGh($Hu+h88$9*ll zOCqnLJ-^Eh89QpH*)<*h8{@nwAn<#usA@mSAQETK#_bgN#IC41ml_- zOsN=nhlbU3#=^hU7+j6$XkI5f7Pug`?2g6z`u7^WNgZTz(nO;t`}($=8$r~Lg?Aty z%bwRME9mNHxt3_|>bUmgiYD?8ZIPzL0yG|0#YZ@H8fHwxGk0vmPnqoIkbfhd$qlQ` z`{(qU`}eK`i-G{Xfld9SrnC>lx1j-kQ5TEGnvHf&x~=QG4ZleFe6ep5!I8- z&y49p_Ys{m`+#r+n53}J7!!zaBb^|wJ8SDYu7n1uK#2?fa(2$P;Rg3;25fYh+V5%i zG5UO?1R~l4W~nCGxUj+60++$mVLdw?&91W_jE`y8cy2zXL!7;VBJ41_VgM`rW@v+kyFm4{ra=ADm+OXZ=U!FNp=_Z({0j z$>+h515mzAA)hSNlam?)-Sq4S3qBtq>8DON-d?3-+4Anx4({y~poIKigMh3lsbGy9 zV1D+&1*^1{ZV4?yQLclIaht1pUZ~4GPKhf0F{>w9V3QTKGQMA1aMBN1pXlu%f@*2L zlG#AO+nqS%(%v!O36e`HjOQNvl$4Jwk26a~m^|EkJ@1_jd)=4z4%K{xT~lWdAD|Z= zlq4$T-`bMo>dYFneCI@JV!w_Zm%gZWE}5CQ+>Lo~=H2+(!x?IGbpDlKr?R`$I_kB5 zAqB4S*gJcKCl~mo8t&P53sz>!D1&^KmbzZ4 z2)=Vk1!x1E*wcQ^9&4BVm7nrNJY#V!hI838ABjOIfXIVFZPCnbaPL?ujhtLE z>Om~_duL29=xLkP+Bm(Gsrd}HhLM)m{>pIv#Ptp0V$kZX@7%>Voi&jJYKAyon(5>C? zq?d8o6js32LE{Gp2y;PTS}LR$K&dsAl0Gtkn3$xOF^jjaFAHf7Q0gO=*D~2Zym$QU z(;z1xe{4y|xzCU|(_Zi6SnnV;9ueoNlk?cozmJG=kn_$UM3MRovNlM9a&J#PxxiZU zg>{G|V3@XbGYPrb0sMFUnbc8=DYGogPUXTXQuqnY;KEDOFUf+-f` zBl#dcSADFiePdzs$k@P_QZ*!r`6E&j3(bWQ;g^Duc2Mv>{uheoDQ5!Q8Ty5UVlxiU%6>{qKhwQ$c2j69X~vFdWc> zH>n*)nW9LVlqs4&9{4sgJlIdCHvv2&yRfvC#1l2`WylaKKyeWffh6T=3L-Os_7af6 z!AKpFG=@Y9KF^1RnO153(FETaz?&A#7=^0_$s;z9A;GlOgfe8N0E|!;=KH2`0%qzJLdDMXmP(Y+$o@Tx(NwQz%h|GwUzC=>r__~{r%5`H+!MqhB(rpIx zUO>Kv_1XyL?o(QMC<*3LxXTq~LP41^i6rKJm^ObfQXhK67bYGpeMA(Nwx)}car+Za zWbzJoM~0lZ2I<{sz4r)d!$V#VAJ?dbwN0R)nSNr893ktCoYxX~4$AuP07mLe6H zG?IkQ#{w+pkYHp0KYOqc&4V%oQ;dQ*%wQ!uoIeINn&M}yxx?SNVoW?c5sxEYdN`4| zVyyWwP*4cP*9SBLSO3a z4vAS1NLW~ssEJholBKXgNl;KMOat2vjO9c)fsAwwxqz95;VDw)L-D`}qH)0&urN^= zkr@bu)HlUygHvg-BNt7ATE2oWc|m@TOsd?g6G5)b})O7DY%jrN(f{I5(!wT^FB8bxsMu+XM%ynYz#)= zL6SZpDPjh+ku)`V&=h%ra_|H!nIdgUiU#y!RS>ArF=#Q2A4)`}5rfQ*Br7PH{*ltu zAaNN`HfTZmh|C1;IiJ~1MiAl1U`;H;5mFFneHw1u33v!G{|qDg!i>;ZMbby_DM5r8 zLkORD+GjpW+f3~~gSaCZDgI*~P4N;SOC%7YBnglQKF)=^W`{+rgaCKf#Eczh7o+z~ z$0TE+g_59)@xa5qTwrteXp3RSKyxI_9xy{eFk|GIB$->zZ)(U2$DBbVMmrf1X3WLX z7EZZK%6ibmKE}fQ2-sYqE%z)yuo{gf7OsjUWp<##fUHBXSOos?mvH>k3jz~Jx|@Tx zSKin**Do|9iswtAhr;qsg2ARwn?53SLWr6gnt)d%X|LlS)f6_d@GkHV^O_%X7MaR-HFNraSe`t<8EmT2TaXsw64Q*VKXIHnHhsxc zri2G>2(`LU;hPep;>O2Z%X+NU5; zP&8K6JDuy#Ra6?@$N{)^s>=(GLPvT(&p*2RsJt+I+PBKbNc}T{Rm!QOKRSG3 z#p6f6|4@FYG|1pGL+#S&&9%PK@(zXg64Mt`aiZPomLPmR$+4 zD(T9M8ti9t%Pm-O5kM(HC_4)Dfp=^tbFwnud^2GsO%Qb;6rYRl_P+W)xuqvlN~Se< z_ts!l>Bm|-?6E9{nM?I=W(V$RR#aEVz@Fh{*pA(anLzsML;HSihB%k*nRaRjy-6I; zWyMRr!SIU)3HXz^+l2+apmOQie<7UAp@9b`?m^p2R|~6Tyl>P#tSZq!OyeHM(pVyd z9wo^w;EXxAxKYZj+N9swjy>FDqfa#C&Vr%b(dz@JRO2Sm`K+|1t^CTS>e8*B`cU;F1EBkH$QqFQp&XHYDbK<7J=rmS0uuxIjqFGr;E0I$ltWV84HvY5=W#w3 zEFpY&;$xOpp0H|}x&&F@V1~=XauQCdxrWP^LVV`^Vr z3dQI(+`-Ji-&&!4B`=IgwUe#QWV?bou4gEhIJZmMUqENkG1WgPxDea-PCut`~MpjePz0={V6 z3H(^0*LiRLtML=evc82;!x*14Gki=qK|-F-F$}KU$%@?KEB)wKp%>8Km3CyY%$bXl28z z1Fx6OWcO5cTc1{CTe|ialC-P)ht63(p>AUjp&bz*ydke6;Hn zVMy{i;OhOuF{aA4V3iXlfz5Nedwj-xU}DdTPbDRmICf>x<3O%hT5aRPJ-%IKmOzwe z+Gf(dF9)pR)_j6{k`L|YfBv%OTVSHM9iA(IK^{3yY3S$bvX3{nlP{43mt9GMpLIes z4^~mUng@o=V#za!0<|@lM*DZb2Bmjy$vxIS8|=Ddb%T)}oAvOyj{yW}a`n9)x>L^9 zD<
E|B%wxiJTz=VVqQafXzlMYt6k6__?!fDrDT>5mYQe)bX$xYB`w`YH{Sqn^u zlvSBkHw>&1Admo>Pz>S${PUXlBv5(^*e){pxYy_npSY z%|bekRve+CZEDXTk=KHRCiQ}s6lfCnA~22(Js%EdT)wAR_d?gLC>Pepu@YLGhPew| z324i+Zx`f33>79&vJPtP-w#;7FQ+e1Mid-A!0Czmja}tG#H&>{wfDcZ+Co$L(ub&Y4Gw{vj8X0AYw$-qs$qg(rA*!l#S3~yl%y?lggdH4>rAaY zioW%LY@xRi^*~AGG~?KXd)@mI^Fdt$H-FBDr8|4UZ1rR%c->;1gU2MEA2?MwUdV*O z;dtDe#g$;~=;x!UqqUMo0?R1GRJ#-NKETiR#bBcDlE(KbA&xH@jjbA6IIKS;l`=Ph!K_wF$(v{)7SeAFAh z(E{5uTLl~k(?Ru}+O47>nBBOYF5I;?X?N^$^r;xTuw%!{8x9mMQ4c+TC5gY6Yj~6Y zFJz}l-Zpl~#NK428F7DhYv71w$4X%1MYs1? z?0QyLyyoxn-l0EB5G>C59rFV1di5FUH_mx`#jTzsyNlUMOOJkqX5Oy8&8hEdXbTjd z$KW%Q8<(ir6Lp&>0$m)xtp^rW_@6T}UopS28IOcz2RNVB$&jA~Z(5lx4hS(oZ)99~ z%oYZ|7-+bCGu60DieSsd?7%q~++&na5Umq>I=^DI`S|mBJ239ujGVO}dNnLI9>wGe z4;Hz`Qp5aRGg$nS)8z{A zy5agDE{nXKfLJ{CV<1Y{ZWh&Z)49Y@*q>F9Ev7rFaRTyimS z)u)ST58=)2rG`j5%?T=A)39>BZVrTaT5PTGXoaI?|3u~rWEZgaOmgD=l130%8KIjIN$gX*)s?m0> zUY7%VcvQ%%u7ua31rn?Wv%xH$zgqB8SS@D9GzlM!&X;* z8a#pS@wOdk-@!`7eC_Ian5g zj7WWGbOq102(O0Er1z3U8nf+Qi6WLO3;pIwPcK*w**?qYW-gO@qWrni|Qmth5o+~<_dlx z&GNBjFOuY{sRtLjs9>R}fNvtYetyWUXD7%`NP7^RWZM<=`{O1qc_}BsN}D#GOGo2P z@pCoriNc<*hVV}pT*SLi`>+MmW{lmuJA5mfLDVr)L;u*h#n&_8TsDb8f~`w=DuZ&i zjL*U(uLk~RDVIsOV%vJ*6rXj3xOF-turB1Th5=9csV8 zrPn9VJ8mi&Nw@xtCt23jNr~#zHDCG*iKZ6`+ts~rSpO$N^EG*||8C^}1QZqP>LG`u z$GzA73R0KpKd`9SNmgRuw}O*)(@F*VUw*wk@S_V6QxIJ-&u z@+>HJr@(DkCTBV#rV`lR-~JD+hQv%K2W(B&(dH+jDI>C0w%rv`%$n<464^_^@90_> zLPHlLhZN;Z+@Y^oX!M;j&Q=>vyIlT^zmZ98B(XPYMlm*|f_{X>y)&#LdV| zPe_8|jH|Ky+S6*p+8VM*)>Y(fM`d_lMIreR(UB|`6dMx5^lH4pvR%qF%%%JoffAX1 zx?|fWu;UQJP*t^sf3!zrI+ek{6M90C8bQ_edKeEaZ|mq@`a~@BGj)xTLZiraHPC}u zyU6oKc4eae5V)mA`-`ul@?~g|tugB6o7xbXT^eFy%I+DWpn04*e`DxsjVnHeLn(sF zcxSm@)-}m6o7(+UD z4S($n@Kcw8=_eAHmXrSgvEDV+chLMXv~TznR!aJ4bBopun*#{=Pd-?M-)EYrpN3z2 zcG-dU8+qeiOYFY>0|BI|JM=zt-$s|vn~T7S5oq)=72v&?V#_8nH64Rv_Eg?kAviAe zr)9wQW5@Pw9V9n1v9+MxjJ}57gl7-rZff+*6$QK?(|@zDZ;N>w4I1T$<<{Ewkv^GnXEqNME!ba`?0PPM_GgiyiGwgY} z=@<2SDMgjbc^ic(N>YvBNW42TE)-evS8yySJ8wfRjffK!V5yD5;L(Z}G;B6BA+t*0 zptyz@uP%mSHA7@>i%{)J3SooM(A72#7}qW6dqQ|fXtpPe9f})6mWSInp+g&dLn~)p znmZa*c|}{VBY?#aHS0d*Mb}(lTuR82d4@Hub8#`+9e7NU97%Q{e5a)-OACzE{(teKC? zFi#(`HrRytXG-BN@Ond1K^ko_4Fb_ij&W8Fi&*K=G5HwwEs1YL$f33?$%&EZhhmH1 zNX&W`U$J0zaoCnADT|?|oGx@E+Y@MQ6HDWw7KdFHD*{x^(802wM0$)`S`pCefhK*4 zyrFaxFw~QxeYQEX`WvS$30#{R&jA)DxSf<(676uXdm&~9+}C2@THzzU6=+8^LF7t_ z6TyNStcP4BS&&*5QK*>gXlHo^hGk}r=9r%4F*QN-4H(&=lX%GWh&d}LjG7v^MzllT zMD>cA6NN~9$ZCr0NME3n(8h>nTUa*HcS%8HWX4{h2-+-(7j2ExSP)~7jQY`t4vRUuY(?kT0&FPJtMpw85J*N!O*md zgx*x&*@M`VHHem9`4IxP`o2|Q1uUV7mP{i3&Fss zdJKoC%ry(ZS!7-#&>%>VlL2uqe3ByYvM9I~gyN7(C3Q5iCr-1%nL;BzWZk^_^eh#A zkp)lSA|fIbFhtP=5Jd!p5fKnU1Q0O?CgveVb1K z6pq7A>t4vM6F0HE*+W{`nYm1R6WxoAaoyRUV`?$I{3qON?8IE=7d2m1nrH>g$+GH0yL-aHk)zV8XoIjN)8e&6^Yu(BUL*XL}Rv@ zrtD^EbHfn8+6u!FD9U9>Cq<1j$mC8tUdB;&9ifGZi!&Yq#G>+4Ah;J%W5r>`VZlhK zqb^EOiXk$akd#pW076(H2C#HO5ZQ(a(5OxS0O|aK#tBk7L7_8lU}IYxgpHmPv71Fp zjg_MzX!Ix((KgYc>{jGZ;a)})HXxx711R2*`xYZ9;`787W(GoVaw=RC@*(aoABWci zz)&l2&+KJlI+-$jAvo$m*F<7du}hI66==rBN;Mb{5|W8D_@a0)Gr*g;C}Q$7FjF2e zZxoFi4OK+Io>5IWL?kdou^{1yzBP!JjS&<`CrBP+uEiaiaNJ!?g(Tj5jY;+}P(l-k zPlG}lAe9Td69ZW&JYf#r^k(3yH-<>fBV)sc2u=jBEeXav`9N777@JI3co(wZXoSix zDO7HT;-aK@jh+h7uqQ>fCZ!dz9f}7-M(60s1YI(nWWkKtH6VVU1f+0;_&#SZLa(9V z`xdY&bp#=a)DmD#2;|Z1=r<76bZJ6X#CRJxJII!BHH-@#l`E4D$4s!!%0=qj2;((j;`@?HnlV2k;MK? z*di%$;B+9C@Yj-bpT{t3m&4b=7lpwDs-|3a7L1gvq|%ITw!TKEks+M*%lo&O_!K2aoTx18v7iI=1)3G(wU zrk_khL1LVF8q71{SzxLrhA4z|)&8gpLOJ=TW z8G%)5K*m^i!BWo7#Uw1xW86P?q3%nSk#l^Ncwh89S@!VoedJWbrziGFF}b!WjsF1H*NQ)Y_&+^SMH6D79ZRzX#1?dm=%QnbwnZr= zWFE@~_^@vU8@y7D@ka5-d7~KSLi$zovB{(pg^7{{Ya0l6p`6hoRD8i(g`5acui! zzu6UjQ1;4?Y)r{(+h$u0cx-6V<=B}NnJD`gfS0PE#WvH&gh4495-$SQu;@h7tlJ1| zL)wFywEqB;1T7Oup%f$*4=?*Dq87)ozDCM7$nw$j;r1xm*p%RzxR;S_FOjZO#7Q#4 z(;r0>T4j_cp*n+G{sAO95+sc{yq?4kC!Y*s*qrihoBg3{HE<=QapWXWn^0?so$@lR zui&djqEc-3V+z{-$O_V48G%iaLdWnmcC5V$Y2VQ`GI3E$s-fi;ybe;k`W=h6V$jwh z2NJX-O9=^iCQYBRiYJxQ5R}k~i4Kw!SuqaOpV|`AOXx};vA8!;A}LBzjpt*2%Lj=3 zOqsCJ4<0|i3OtR3@I4aD)9ls+^*o6PO)4@V`|OM$(@6=kC0S*EvMZ8y=?yboQ}8JH zX*H!zgxwoam`3R^BwAdoUK**XvM&c*B}7RRsSr|a`zCGS@0T(YDN1Zu+oc=4HxWuP z^3$4J4UN&hiZ^*|Zv`)cva*y~Dx`-}a~O`0(KhO@UW%hCNt!}rlzE=T-kx#J`Whs4^*?p9}FR?36B`TVQ;j<=6UTX4RMJ`G#reY_Z@ki`zzQ)f7 z{12xKfidw+lzZW}FGfl}8jT(7dW=sqBAM07?1b70LxomrTOT#v@A?w)!d}>|v{SqZ z(@VY?>Kl}ceHH%zkzMSCvFZN+iFb#8qugtTi}H)XBq*79thjCvN0L02m9A(LIvcSz z(Sfp=4MbcGt{)oNQ1XPSJ&it^73_K)Gujop;m6s5qdrBkvA?h2VoIUyF-0M*R}C>| zl8af%o2ra`34QI`GyILYR+Z4&^GP8wbxglW3ESWFMeIP=ISprQX>f+!CHx*q5)ivS!(pZYEg)>HtqsAq3d&q@Y2m^kZz9R8jnaAEK7`0Nk2kF@SvK$M)8CzHjL4qV@xjq zlk87IWnvAl0&Bphf-gc#%KilBf6$)vS~umF*?pg3v-TqUFS3-r%kPAE8}MIcD4f$9 zaHaNAl)lPeWiJPjeV5qZvimQ-3}iQ*jr%XL`xLn=qHKaSp=}k*u-P_8Vu~hLKVa)u zs$H`vBk8Z;{{YM#Xu=vkhKsN4YuENKL1_L)$Vy19p(5-1;uNG6aN0#FN>Y@iDNB-+ zr5i5_QL>bN1slf-F-FQ!w#*R&LI#w9v%V6G+szY#t@zV>DsW7?$W!JwEe(FCd_zJ# zpGW+Syg%effA(kSRLr_W6sS!Urb~k&@T7P=kgLf`REmmHl%lw?k||3#QCUhcN-;(Q zt`IbY4W>SYDn%PbNTX<}4l-Bzgskv{jyws)D+^jQ{3zY_kEkux683`nUH79BFK5_w z_x+8>wrsXCot1bJcp&>9VK;VthW(2n`U?e9XV`wjd^GYV9$Om|_B^&$QkV}O6s0J| zK7-^^mH8=OLvP7Torv&11XbW+@VvG^Zb#%&tM)94i+G*{)XNiZJ0fi~Zf=*6$NvDf zB0ZUeo|)@f40{YgJ{l(oHft9&QbbM`ay275yb9jetWmL2 z(_eg538D%%f)U1wP_2W-bP>^ZA2&k+MC``3pVE2ZEKE-}S{gilUtHB-# z_~L%c?4|Z!W%hl!euXgjdMlBYiCKM(xj>K@H zippWm=ukl(M;(jUz;)U8;_I>zBt97z-wk=b++B~@b>9tmwBX~u5JMV4Y)A4&cBvW< zJ8POr;7p9CW5lnblw4?Jj0}Ywl%*+t5|pe%ZfGEa3R0JYkA%aLjltGR=X5~@7_7je zheiXUmnFerN>Q@0JPH#Z7#d}XY^)#9)Ut83p?al0!pyfNrEy+`^nD7v5WWX(miAv| zEIx%7*?pgHgu|T*SMf)|1Q)?y3Q_bLai`d>(1d-DC^bSznNl(>idhO$l%*1IyeUfIMc|PY67MR0E=DMj*8MJ`G=N>Q?uZ-)8*+2MR)L;wH) literal 0 HcmV?d00001 diff --git a/packages/ui/public/sample-image-3.jpg b/packages/ui/public/sample-image-3.jpg new file mode 100644 index 0000000000000000000000000000000000000000..e36b50dbdbab03c436d616a539739c11e5e31e0f GIT binary patch literal 126577 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

>eV>kHmd_bo1J8Q00f6iXu+RanZ@7?3gR?`O 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 literal 0 HcmV?d00001 diff --git a/packages/ui/public/sample-video.mp4 b/packages/ui/public/sample-video.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..0a4dd5b4017139bbdb24fc28433c594ebfe2d435 GIT binary patch literal 788493 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%0D@RQr;(ovPaP5NwHr%B&rYY#NS}E~_d<}D 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 z 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�itwTBdp3jh}?x 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 yAc{ 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

mrFQG}D)1QlsaMIH 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

S#gwml0D8+ z+os-y)=l>US*Md;aqDKqK&>uos*J3DMU|{VsY1}7^1nQXb}t4X9#gU~E6QCs>jn87 zBt8-Z3bRvK6t47p`_{UiSt~Bf$k(g3opODzHtlQakdIh(%Fp2%_btj!hI&iRyJ0}d zEmoB)i3A9JF$E3Nus)CV6;mUGD@tbU1B>Y~_M5N1Gf^%Mj}J9-xt-@lMQC}VTEDx) z<%OZRiG!z?5H_3mliOZh3>q7}>F_YNw6$4lv(U=5|JO_3rxaA%ZklYjldmv~37!^k zb-6nM_VFUOe&OaflncVdnsoh_y_%&f3kW&dS55H1utQX6FkClKcZ)8E0`J$gN6&e@ zLPP!7J7kn`|G{QZI*X?(0N=5g!fa+ybisaZwE0HP7{!Gm1UlC9qSTkBe(tb8PiqS* zgD__r4KwFEfiUUN)f+7|)gVzu*)h5lraj72e6U4oCWHeHPV;CE_1rxMJL-VAxJ54C z(njl=Vt_BsSlD7Q-KSh~WaiuVk>c2cLmQvDXCc=R@Df_`r%005XGzE3F4ZT1jqn-8 z4jyVHsJ$+BlXQ4d_|+iFa@1D@c_D#D15p2NJL}{15)Jc!eOr@yXCstu?ji^-0g=t? za!ik&J~Y!&U?B^O_x-p1|8npq3=M{XfmmoP6cY&o!%(`Tp43@@M+ za#ZRo*`q6IjJRPQW!wTh--?+<;ZEtjOjmnPM^}mqOm7f7VSxnQ(XDS@*^mRS zdnmCM=jHpaZGts|W7S<91T8^EJIx^rdo6)FmR7O;bpSyn)3`<%ERaJm5pWt527>`% z!6+ye3Wb8^N0`o8Y^?&e(@-j2K~dkU`| zKFhp5=qB|TUU7RhZ{N57^cIU;@XLpRdE7eDr1H=h^FNDv5yto6Jk@E_wk^BiZJ!bg zx`eyFUeQ|n`~Eexvu-~53@+gSP^k!=Coa71bl>%RJASG)tWvY%V^-+iCC)T9c_A$B zy!?Ew7#*wkOfjjD3*X`5tsZ&KN{yFW%CV-A#|QK>le7y>B=kf}6oHC4gy%HEi-LnR zPLvEmW=j-7J9j|fAq$W9|KIxmvM?qL1%m=WxL_<84FyE zxzjA=ayZ_`khTztZ~hyyTHe1EiO)}EU_8%;S!j~avKk5DoAwHF7L?GAg*#lC^jy&a zB3Am+KqB{_5SUG%vA<+98%qI_as+(wFwK7aytn`uCP)bfjBo)b0-&&HFcusRgu!s2 zSSl6@g#y8Fuuy6<5QM@jbDeiM|4;8$s`EPEK6}*M*16KP&bP++RH=OZ!do4O_U?%} z@!aWX_t)d;pI`m_0QA2=b|%u^56#OtH?5Sn)~)RC)xXZ?g;HBDx3QNW{HQyHF5h9p z`gR|8llm8~(_%y~FXm@r1R4McZ2Q<47%k!V0*o1FK703?_n%G_te=WD)#AxOkBrHN z-5K?@b4`mAo8I?ojklk5%A5ocmzd77|2fkXsHTL(_EI*IM_@K9T1UJ>Rv-#OQxZ~Q zV73CQaTd5ZAq$SsZ|__G(vT(;3BqB3xTrE43kAZ&K(Jg&5()*vVQ`p4DiaW`?|RJF zpM6rd=US@c#}_|BS*r~(}jB3AjeB=QLTkVod^Kol4E`)ht$MCzo&bfb%2JwtSghb*Qf+ov%|Y$gng%$6ch0a zK;l%2U|xDAEf(tZ4bP<}1e7E*1d%okwgNSSL9no3OcV1mrZ+my2@+Y9Qo&rmBjAXHzv8@*DYrPZ&i27IXutWt%)z|ZvA}w zZ)dJ$>Z77Ny@*xzD}htxLlLMS&GtR#Q*ZqNkBDVPUx(=aiG$P&x}7h}V4Rm-+;^J3 zyh_nD6sW<$^S_u=7fS#3e@Nd?Q%E@&3Pa61QW5RfUy~SeZ&qw!UoY(7j}XP*OIzRZ z-(5AFx=ga2<2;O3e!FQr40I+_1t3NEuXr;R&?$uymK(%7;$hWga+O4o9Fd4_`+x@_ z3y`b% z#GUuz)?rf)aT_ahs(t(!?U#$|q~-|Us1a})3II|MlF8J-<|39BMQ>hw(*tEWO|7tq2YhRUq zbRftp6b}(AEZ@WI01}tVA4Qq@_4*rv(~GT!8`&W~$e~e5TA(dr;YR*9f~$c-*0>|= z0l*;(imzwA-~ZCkCL9Hc0bx*_EF=pJ1pz@QNG=r#1wtWEirn0)pI-jm)%w?;J}&-$ z3hw&vt?5_3H`CQ$N5DS^QLXcOKf8R}2j=6|u3`N3R;fBO@}RvbN4BK@vJWl$CjqDW zG@Y(&Aj#KgDgyC3lw{4AVJ5Fi9{jxt4wlPXt;K z>AM#ePe<3AS^Ltk%{4P<)bk6_mA#E7l$#1u4XQOEyf5F4STaF8P;F2xp3hW_f!Im~ zcF*9vU;}+&D)6@9EngU-7oJ?gXg~$q2_bNm0GW`$Xe=5F1q8u>xM(sM426P&V8D&UA5Tm^9p>uwuAWZAB6nS*uiiAfGvqnH#IIz2Y1qcdCp%sX3fE*zU zkL{Q4-T(3sHcN(tfl#1WNEQkOM1oL|OhOX~gu*5;i66!Ne5clPtj}NRxVL;wdiZzN zOWbkaobhvm=rzsoY3|LBqu(~a#l9Twzh=iC{L1+~?)tgf94H^2_XcEcdj})-r=NdE z=m#$mBh>KXKQ_m5&|t(S#@Nu5W9{29XgK;J*6Yvi_GvHB%hjd}u67s!*ZX26TBDKx z%Aeql=YqBW@>Owrqwt|?`gRaT*=AHacc>DG$xtWw>EaX$hMNC!p?oWaenx=BKn$hD zh?@XQK$uh(3x$H=fUux6CJF_Ffngw2ND>T$f`L$wR3Z}ygu*Fqao@Fd^Y!AL{_1AD zd6k@BzqaM?S=R39NcsWmQ{Z{MK6%8{yCLUJPo38T$?Ma<{M-uJR*X-nBWB+wxYgPR zm*xwerL-+k0gpG-LVT)R<9F(SQG%;R??Vo4^6mIB7Am+!E&em1$&0Q;)PGnDvL?7G zyWqB4oXSMznH#-nBlQTrzm{~A5Gv%jG^9Eg{QbKCz0yj&3s=4JY4=@OOcJEMt`uxR zAaqom5e)|^lOa)fiOnLxN>py393cyj`|rQk|MLzS6a|9fK(LT37!3x(!a%4{EEEcb z0^vZAR45V(gv22*irHLmPAW$I{l1;L`TExUdpqlQ9COD#J!?8XgZrO$eh}8IK8+p0 z?S902{YAz;8?8f%{AC%}H%E`~6T+$fC`|i`@z%w4o3F8dGhSa9=TtV_^;{n`-Mtar zNru1m3y;>HIcHU`sWlZjVNF&uQO6kU3)|)B?S)Q{BIuZS8Iz>XFT!=>(P23hR#EjN z^B?AR)uKEOsw62t=A`r01qu{xu4RSFgYnbsxUq^Mc~02@lHe~G4bTF20xpFCV9;1_ z790kI!9cK3EEft5f`V|UP$m%yghF8zzm0M0j=KE+KVpZ;g{_nld zbI?it)tJ!EZ|KG-A}>^+Bhdt`h-{h`)`Nv48T z(A(PeDv2nek>SNkx|>~E;5{?VirB#pVh4Y9XO2tB5ySXe=BR1bO!6Y6&`_0 z$tRX~oJWhyc+X4T{1tmY%a?l6@`pVL`~&O}ObWLgIViK#<8Z4IEzX{4&MEG2mnGbA zD_p-AW5Y}njE}u_N)J&LFIO-N>^8{xj7z7=NY4cXivU+k zi>@;%kj|JV-lEC%1YZ)dxru<4FHpYP@z z{dP#3xzMmmUvpSiWo3fCq2{KcxqKGh7xY{CdnX1~z~xS~O#6a1y!~`?Tghh2bFQ(D z!J;IK;qmc48R>H5dd_e2>P1(6AX9z@!%Dtgz>1g+sx&FNQ%*~8A1%syA4)l=_tYhd zW$h1QB!l;sPiF^zXomfZm!Uv_s4Wjr*aZihv>3AzJ~0>|;&1 z&#cEhIV4(OR$hM2DTcz@Lh^+n4pI%gf^j^fB26X7L;WJH+Xo($uI=g7?!CBHG7|KOjy23BSi!}Ey`S~PZkIUeuyXJu!zBn3l_4X@1N zH1LeZqb-WxOs$CjeS`Q}Sja#Xt2b+(jV&lZ`ZtqHd2|gSaq3E#6irj*=UajlOt|!c&=y69-G|@s4bGvmN zUWXu;c?Q2k`HpqMgfginnbLPG6h0nc+0FA7lS8=Bvkl81tr* z(^h#@4|*9Of*M+*nC5uIDHNv9ldX?TX>sNt`R>pk=N3V9u<11jtN1z=w0IM6n3dmn zb#+ixm2oSYM?m5j$gCNnoNzF#<^JwrnaKb;Q7_8JYag{~u)ca9o9toaFRFw6V)hPj zQyReHa`v7|$##h^_&j%BX;tXd^MGA=j5ICpGKt5oj>f!0kU5RXfr&jSsLG9+#;%5P zy!vF$7jyN{wFE!^hcOWW<2oQ@6ktr?sRYgz17!n95@I&vY0N#` zE!tv^9{CRHUt~3tR1+7yOJz}!vwug5Ra0^LYWJm#jkv1ob4&m74knjky?JY=_7NIe z8c&st);Dvo>(%h+)U6Oviy1FV$?-a_M6is*0?UBDhV}nNn%cNg4x%*NRt?1bw;QQT z2!jGhqMoVdUH(P}2;aKtQ9`a?AkeRC0&ZX5HiA?EkMO7H<|oc1{P!_g*)`&fIeYjb zQj!fdxTzYo$`N z@UvbUdq{p@xK}Esp;XVLlc>TyA^bT=yJpj!)nn#SUH>m;8q-Z6NOt)kBcpaw48BME zU^ea#HG=NS?1{wb^%w(k}2S7*6Jzrfhy-b7s}I6(|#=`c6A~jU@!jm zM+%5{r3@#R{Q0+l0Arq^h-DP??nHSozoiOwOfQPRy%eHE0{FNxd`!AU&2u2l#VJBAoxf@n|0+jb5rbJykv`n!l`V=5@L&c4LDc%d?bGv=Z zoEgU+htT2M`@6&G=lJKBj5-U|s47X=GPwz(e=az7}K6C_{>jxD6U*J*zlu_vL(oLIX?115M;!IoG~ANpzg zyEMOd;FIMdSQNhYFKnU(0cP<$vQG^Xpk#RJlsv)aQ%KOiuxTnyC+2#)y&@9*@o-kJXq2OH-BX=-0-n z);6q*AG0(d>*Mz2IfesM@+bGzsH^=aY)8kc3K$+N>~5K&xv1INOEyKIz6DL+JT0lt zP8M!8C&}|vJHOqEt}7baxq2}tQZ;c|qM-;T>ZscwlBdfTaF;|yMl|_?vdJofpt}D=8#S$Z^J8 z(o3OxEC&y|)`WyO8Ju0{&Vd`9st|F?*xG?$`DVM%L+l3z%s%Ab^2g?nR3?CVFMyl{ z9DdFj|3S`o`Js~9rC7QxuddfHt5LD^*JEmdK0+h_oNEAZ@)15+E&dY-5Goa9lB>x< z2&AuUJmr%RJ*yfg(h2~H8UDRH+gY+N`3@}ZwZ z?ZhZtJJ?P%1Wx|;`7znFqrj_idI9VNKaizew`>pJ+{1kegzF7Zc&;?j|K-lv92l-( zt4KtjR=?|kck0hS9Q=rGBlV}+wULry=0~RZ*)cVI7Z2_K1D@cONqMDYQG^%SaK{LMnQf;}vxNFo*7@aHZpZBeA0o?bSpwe-DJn z1192FXy`P76RNfJSfOYeYN-YQxm0D@fTPK|F+Yz za?ph>7Er&Y&^^AseWSI?@1Acg6qodB)FX7xwgM%Sy)djtXh?FsJyDTU)x=OdY6KIP zFiDaPcl95Kc*y+H0zjPF_(03cWFnUJDKQvGER$o!$M_}*#OVN5;&j*Z^CLbETFqV8 zzf{PeMxAVa_8{-E=3T$xnVJ@xjP>TWxB5Ax+#3#IQ}EE!$+kQYQ~Uc#8k*jqYcTUj z6v%kne+KHt89G&hDR1zt-|ySVRS6DPzm%(Yl5=)BdD1 zCXljG6g^{lH;b|8$bzX%K-ArhBw>pK4s`@I?RV!O$$Y-y>NvZ17`*RsnQ01bV#fA| z|BIgEN2ec4E1hPimK!?*ICFZw)!B(i=wi@WI-4E_rmseDMBVGJ7enf7n*|cXNBOk_ zB26Dg`(XF=g}FgG3_V3OONp{=UqePoetysi@(_dPX{KmvaLC7Bwy4#i1Wl?tO7Y;O zy&)p`mN~^vSR}>#)ZGIdi|4xl{v-e#ZB3|kmC2rmJ{_Vi^HXjE&_76IqCan8& z;&pX9Qj_CQ4&)Cl>wz0x{+ztq{kVUq^}D8}>%?#IDs-*mmixg7;=c44<deJGVT2bK!YO=WoHsb0uGKV-UrP}eZ{!f%=Qjs zFe+Hu(KRR)1Lhu)KocnOIQAt6(plgt0+S5G8NF;fM;^t*OTmaK&B@wNG93#8-EGiGqmvob*{pv^v6KND=9ALzrIo^XQs0E$z5vkERoo(DO5LmuArS5> zki5i4UPZ$iyL+4^A*0{*aM`NG>gz-*V?G^Oa}wqK(huix?6l6maj@DI?Y2W`v@m#) zc^UONQ|RP|0XS-CqJ*BIX)E+EW*dGfjnHeNBnkBkaUpevP;Dm7Y3HXlP-MU&9Nu*{ z!AFZ43ACtVZT|@;>k~}AL#yLoe&i6$H}x=^%Jxg?u|l62F}{hi^Yl` z?@F*EDRhecVWEmZB+$hcSJZk?I6Af?n-8KU%>PatQz>e&oNI5rS! z6~qO+6+mD1=`ytk{(;g1TsCij*W;hd28dNLxH%JrZADeQyUeIKgZUMnooVs+LgmT8 zaa2E{9o4B8AiJ<4t-MFij&ZNYEx8f8guC)5{G>uOf^hzepAT5)7mvUA%RTSgbFR^D zvQ(t^tum(`8jYWRq{Ai_K@;Z?p4WOGgQmE~SjAP8j8 znA3JV%3_Vv@$i-z$(zN>gE<3qD)%^t8O2vIh_fPL8i(X)8mvXqVdaCw<47zyjM5U8 zh>n1Ok}Z)=PZ|LiSfMPI8^Ie18mk>*<7SDW!6J<7I1z1}pf>{B^$dS=ILPvOIzN^sc<0!_o(P4$=0#mV<{nWT?*d%_s3-OZ%U-s)EI4 zDr|8iKOTvQ==yt5%twC~gZkVd{OmeSt2>Hd*hSW3cKTggXe$%J*u(&4LFAvjqn|1y8%>|ly+ z))x!&icXWdv<;LF|7{0xmAqCnP9QKaU#Y8Wf}*6an0$9jYg}EJ!({;lTI&#{jHrq9 z;ZD;Q(^{WTpH zSJMkdhF2nU3<4e58*2{l&8a@H@cK@_2zsZYjajK@D!6WG)ZkNe|6UVMp3d_%M2Iab zHYJEx5tIG}rFrNuN!}iMX2pYcgIeiO;1}#_?L$ore0(T`+XDX@nTS;JY}SAA|&-9r&Y)KqodO&A>!dMZ@9z070fg$VWS zBfmn7rCC0g+z&Pd8<;g6^sZP%HR-YlFvqm;M1y2a%)XgLxVEA_zb$+D9J?*d3Cqx| zO!v|6#|lc{m-pP$iLp|@ohnx*hMhgW7rtTGN!?c@IdsGVJ<6XvqZn6`Tq!7#$>DMDvp^5k84RfOK*^cQcBTQ=Lo^?ISyn zo(3&?Z@+r%BB8CEgN$}!#fs<5{e9;Yn*CVZ` zvM9<(?{G33;QU0ErMm9M^ve#`?g7gMUtpw&mV;UVyTP2ROEFIgODJ%kMMK#N8%<2Y5r-riea1J@dn^L0JNqF79o*%?XhKcnAoH zz7pAzl5FsrjBb#(7H#NVKFTvnaK(M)v+Bsa@x%`=q`$pl5fWaF%P$Nmj+uBASjzAg zW|jTSq|vO0ThOS2*fNtxcEi$fbIa^t*Tq>TGo9S|%m1?R948!px&E1Sv=m6&vL{#M zIl=}SIV3=ehuCK?xdRLwKJ-(T$IPf$_23z1nW?u~YJJE|dr=|}_nHRkR;{+`L`Fn> z9SR>G-BE1hIr*%%LF5wr-%RMrHrO+9$q*Zw9a>%;%>LS?!^vEkP?xpz;ejqQyxh`7 z?Y3&nl+(0>tQ94j(${~MKxMJ#gW{7@hND$44fn44ryWD(8*c4bHU?C;ib!QBeut!% zcY&kEw02U5XBnt12W*|MUJLM}=bIPaJU=x0kaB-0`U9)ups?}UWr^I2b}S+BYm#f!918#T2+cV=daXCT_8oRN~T8$Ka*e%`pPV(@^ zMI`GKMoz?DO66-4Fx>get^r6DgfU5=#FlMf-85NhA9f-%wOM!sC?AL<4T` z`HlCl&8jsQ$%YB{p;)7|X%tsk4@uZO&Jt>z@SCD=F7ok70$;&bF3~~P-}YMTmn7D+hv8ohJ$u;p+|UqQY#a{V#5sHy%Y_D_rwh??pD{iL{=?mf*=ABY!CDIu zR*Qs#z$O*j{QB3P*r8@?8%k0}vh}5bq}75=^rY=AHPTa0Or;Ku?@n%!Jns93oC`>p zspix*$(A-Dc6#-{n+P#`iyk}i)yx0JTyuN297j^wEd(-8KQ{|_+3(NHOlf!WmAlUN z3co3jF2S~k_RJRaaEIEGP|Kc@twVm1V`-0+HZ^BA+}{~j&FN}N@P_ASC%09IpyjLL zkQ21Kp-k!X&)?9Rr4q2e6A&9qXXbhL}(h7;n41aRzU^oXqaT5??AKF%f20~Ls z2f{xXeLhDc5;k9m-?ju-jnjV$6ik?5l8I3|8%--O&KfH?{J_r++Bu? z7X;P{GQ~^i=%t*68usUOc~%dk zB31s}^et-I4>6MKJ8h94QG=sqMUWjZbZi+?*3F1Z27l3~#XkGuNb{BBenyVwG9cyE zyVYeU^kHG!A?8=I-#W^LYO_gRf3n}2NaT!`mf{Q!#bG-j3Rb|`%-Tf9L(!ta+Yqtf zV*bXW_|6V|badk_kg6r@zia^8aBSQ)I;mSPP^;fISalp2t370LS288i6tB~;oCnoq z_S`d}yy6Fk__@6aMRFK6Tdp~SU5dUgk$hf@K|C5Z`|W0qC(KVOzMuIDgXLf#9_RJS zj0)y7zb8kDh^eA`rSy0pvs?;hY>Gbe%OGBkIFv6e*J?rr{8ILxX$hK2rhA#|iKIU5 zGO+#b*L<&21)Hqe{Ibh^&bHK55|e{TWgk=R`ByG?$v?arHfiEZ4XJYysZ`=IU%73H zHVLEoT1T!N4`*%sGLj)X{?tu;croW94OFK4m>B!jIG==q4&~^UzSH}&(p`DfWahI^lDP+|(2cZDc zy%C2Ua?r7)ZmGG03X9xk$T~c*-}#}TuUx@#K3K!VuDC`?B0A0{$J-9Ozj`rmvwZjc zezN(Dvm!C4l*4u2+_|qV<5yZ6EVQuw;8#=V0Xdj?%?HnKlk0viXc_nzAQM4PnC&_p zemuyq+wuP--KL^q#-$(a(_33wwzolsd@(wH=EZA)Ir8;aoINY)oQxWxdZbFGyQj3- z7l(u7&ExVWuws$z&`N=*)TJQv-0>GEO~#o90K8%EUawpOU) zHn$f(9+Q%^79?9Z=%)pK9GL~-?s)|eHe5Q43YJJ<4x?CHq)Ub7Q}lOEjK+li+Smv& zDm7yXG2iZO-=1S=tJnXPyH1`R+Z{7neSq{EcDfq4)MxTs$--C+eY#Sy1_QN3pxWh1 z3AYwcN11fxh>eBl+{PZ)iwpJ~9G;e%|pbXpblsu^OG?x-Ihx8BOfCe-6+Iu?%l93*AlUtLjKlLOTFUZRd| z;8m&W8#|_(`r{ZkBe>6OYv-{3WFXtEIL1oa>*R7K$rW^H>4)%DiV-MU4)%@w4a-C+ zBWb3as2~#>%ukra{38(OJ2N0NMtQt2mLh+~qZMqO=m~@RJix!lZ#aJN`}68;#8Qyv z@FR6$X7=AdR!wgW9ou@4PYZKnPcK>M`!v2WVNDRISIxc09Fuey{lkeGhQlFFl={_Z zyP}f?%Zj)znCM{skmY^+%eUY7C!58?lz%qpENi~1wvImjqPg=Jd;GGFidf4)9~{v9 zz)a%K^XDT{36?I-#-(@8Dc*O|$j;}RT(WJWt#w&ZENz-^Gd^&b`oOAuzu4uxB)}2a zVN%ywb?b;n;@_`Crj-+573JD(QO)7FZo$EjxX8cIRLZGZWaq!+D!=kyopv$<7)&_K?Dy(O$gwBr(SN0ZTq$L5Da z{SXnhe;WyBk+{ii3dUIch5@F-FC?%^gc&wvJpDcQZmP{c7CXUx8vZ| znyS^>F@KH?8VL1%%;Lg8v9~a>egr*K&s<+^c6~ZkJ|>Usg`xQREDU6ZMJt@zCi)p3 z75W(HeNGZG+~_QGSda7Fi8mXKv*oyU>8i}Iz2h;zV+<}ZJN`?rvB60Sd5K{+XVwY( zPw}L#d^?gfcfUrrOie3H2bMO<7KbT^|85djz3QXTre=1l(1}qaIrc;{RHffXQq&>* zao>D7=R>GtJuAHLNyPd?0Oo?>7Pf;{$I06TVuL$8UTb3W6<%aVCuQy4p4i%@9z}5E zUe|~yDS`T`k+Yd+a*{hLs|1)atv3`$f4qyGSFay=lzkUgR_AQ7l z@m^_8yxP0{9hUf?S1H-Q*%HDA!}A5ME~RGje*_fWk^)2Oz!FsMAL|p#d3AR(DjmI2 zoyuIaRzJIF)b=#>!i*R0v71oT+*>fHDnkYOWw>*V;}mfS`2#U&{R)0;e+J1FrX%TW z;oCPrRRqi5vm5i>zTtKy!!qH8B2aim(~PFfKykJ^vYHZdT;Et#WG zb%9#TrZV&JnY^OH(tCl)5grK=OeU#NTuwu(X!hqfAKY!a2)~QhzoeqAi2U8SD1{l6 zP`(oyyH+62Ujqr1ey|u9)T?LQI^Rk8=s8~y<{E@JP5LTg9c5|-D)ZSi-`}(ru4HR8 zO~mg$4?o&FaSLkt9RB*Ofiy^hTMI;jgD=lhrfC2drT73%c4!_%YjBaV{@g>!#h{sRY0hb2?}gRGeRAvpXVP^0yMEv$L2#8ZU&P?roT$Bp{F2mmoR_rtj7Ub@diG`KC>t|X z&l=3&Rx?q4RH%A66mL~;n$@HWkL?uA#$9^99?#4`3vc^WU)^<&NBNR-3xz6XkBLq7 zniK|MKC_FBEblGx6w@6yh}{~P)fvs9`s|&?x>la>L1EB|o_baNjTJ`#d5p|3{nv?c zsk`FG#=fQN5vz{|ZId)uQDBuci2u2w)Ia0D+C+|5&w&9w(57YP$3h9tqag*_dMqKz zcc2^%gU?1fU63rzuJPG%(2HxAc~PIAn;v9I+ZqK_R7d-(aGY9ykqoMBy;;!hul}FF0+A5(WmR01s9m z)zr{$4(%Wshwf(z)J(=i&Sc%mjuX17Kwf1iA|TD+eNHmU-24^1+ zM{b~_N{@&TnA_IqEmW)8d*?9H9!Tg5yBdc0ee`|E3UzUJtC$11&YiZoXoC=gj(HT` zV;-J$Sn-4APkAYKH*T-}KMePsIk(}&b-u^HZahuowv}rmYrbc!Vz=g3$7g~ykZHxPu&rOXP?C?Vpb&rKsF$=jcWf5d)=J@5cxv;&CFw)bd2 z5CYjtKCoOZ3np?1GFdlIQbD>l9#42>(l6?#{_Aec-Q%P42`K?KAmgen)Fxy@MUnuN z6!b(GD1eL$=r%X|ugsqHhr4b0`rnNTgH#M{vgGGQJTK3t=c*fxdRD-P7u#2c{9O>L zEala37}cLSyyseQTIj zkZ#xVH)BL1S3O{;@1VF({yi^_gW3lp2@$X{)WYowJ?4RGKA1$zLVKf<26$jP~A z{Ef$3cZd`$XtNj_-+;4>Sk+nv^8bKDt>;hj5Ce7+U^cQL!39hXo+6N`OAUZ2d`RzW zzxM4;feLMp8bLQO=XZ#KjSLlUcmmyT=8R^~g z-Me_(^RWEWni|>0pEe*zL(vr!RLA9Ji`8lm^e#A_de3~ErEY_w(ls8xB+X~8VG8Vy zD#Il0+dGzIRlj>u-PRZxYF*8POOfkf-sBu|F{<5`>pV4fpPf<6FMfAFxq?U~UJs#f z9f|+$rF5OiO0E?r%>28Cw1*6S6d@%@{SZv+p~@(Y$%ByO2zt5e521T$5%IK&T?h!I`{mg%r%JP-mU&*0@ z-@M-mh5bk;-a#`J;y7xFqj>Pgh`Q9a#g1*4?b7YTQrZG3zi~`T2_kv7b@RwErA3l< zOaG%!9A4}w^(%yFGyhoyp$TO$52p-TWx{tP`9cY|-nm>T(z&{7tCQOsgdZN+>%d9I zta?PXz|Skmu9;|@1fGw7PWR&-Kg$8 zPtZDNo}|-d@4ZY;+0!*2U2y*q0&8QHT!m-foS^=IbnS2;9~#}^K{cq^Y6FgBy@)`L=eu=1WOhD4tHS;Ql#D{*Yv3IqRi& zPYOf#uQ|AijN#{4rT)L?TX?;SnimxBjs-SVL>^V31;2rt!0Y>?^Kk@2&hT-uURDtFXwf(aTVMogDaC-fH#WBUc`H66cGF_?j!8Saw%C$M6Vg4-AgI}$;!`REpIpT$fSP$F&gOhzO@f;h z$ZO)XC=X1@Rrd8nNK9Z_o>jr|uXIj3jU46oKjxh!OA}}Nq~(j=DJ2qxGtZGBe$Smm zT=}b%>j+%B%b?||0H-5hMFHt4#Zi@*=qpOd(}<4<6Qy@Uywu=dp(#GIR7^8bf?gGv z{Hmt1N+jtY_M;>cEv!*&yQ;Na`vNWqGgx9(IaK_H(E-MT~@yaBlV>h zQxjyA7P+;^+XJ00XVRgtj_jnvXTNKvd?;BZ{JJDIPHI3<#V?&)-_e|rbF%#%boeGe zJh~7}MsKzn7Sx`1!S_F4=(Iv!pr&rvu%)S7&A*H=_!``HgFx_*Et55RR$fCCNM3iO zH}SnV<6eN#sY3%rYTdW6eSEP?3DpkddVqi=C-`j9NnHMP9iV1a`Uawnu+TD`%g39QrHn6d;>y?BvJ=Qde_hJ#4iEa= zG9SI9_%j|LvyK`bbfT-CCG-65StKy;Y_HmM+np*US5KEw#(WfMZfA;KG%{kIR;WsZFlC=z8?yp!~6tXz278F0Fi+V9#)9l{k{8-ilzF# z2baP#KY>i`lebl{@mED|6wkc8W5PV5oCXj2CyHc|uB@*TD)!_pKQi^>tp1LWr&Qsw zeS8_ks`YEFY49s5TH}uALzr=AkU=M*e*WmTvCZUp+t2edjL)hi;M2PsNiK6=c(qrH z-%Gq`Rxj}GX|?30*$h{){s3d7!AjTeY2TZ@=0)um`oaT`qZgUwlF2YEfmEd(t9`*M0(`gF^wG zJD{c@!T1i$-!p~ocG{g<6K~I^n!CP23|5K^()tKG*#>gP?eA*L9WOX;N;-<~rw8F! zrANzC$U1_NZS&Uc6PmNhm5(WNKhgIeN@j7S$vWD*;BjE;lmKwZFOi>JTM)U97e!QW zE5vxKQY9a#DzuWY1B3jef|u4dZP=}pJ&td=DH+}wTf+uP$QET4AtBb9rcz2n9efC- z1UZ~L^%JgGy>CwFSjLxB_vt*f;uXBu=cyGtnvlp)qCHfxUt_)}LwUb^gE}ym{^?0? z00BP;0hzjtv`?|~-N2`cjrtW(dI4`LP(*A1ivOn^Qh8H+{@wJhXrC>e>>U4VP}%WE zr{RL^@;hk8oaHsbRR`Q+7kYm3DDto@rubDWd`~ z`=!u8lZz#wd~D9VWu)~E*ud1taFBBs`1Yf#McDEp(0HO~T)2a+?6KqAugqXoh%G{j zq$cL*+GVu3%uD8RxITPdSMFfYB7k652wPkI@a^?1CWddxf}<__Z^@Z8IuUT=_ri2p zK~pwm@0S&-*nX3%cPI^!Y5|90Q}x|g`K2EC%H#=#_x;(%yMfx3-y8y)N0((>9 zv8t@V==wLi?}5wg<73B1HxQDGpxvLti1OCz+cGBZZGwqgLAbAffR0dT!Dx2P#O&~A z$3=$>Eg04ZU&eWZw>1^kSKQMNDYv5I1>fShn=MJ^wmVeEZ`6`o=v}jqgeFuUKFA%( zCE2cAz;|)p6I{X}(>ya>9O!?9cQ*o5JHmNZVKyay*y7kvoZAOGe$vl2WOusGJ+`wV zJ+~hQdtphD`8&j5mn!sMwY3+#L3>ZZv-UPCFv3w)L8~|a=ftzV&qpZEe?p`TEn)%b zUc`fq&j}pr3{*>zfb2aL*ogxoSB-Ns+3_(^f@xHNRU3k5m7RQdkiJ2I-9vBaR>uA~ zNm9S?r!oFMkMfxuiQAffhADdGocD|lINT*|O5`8KuSo*1gN99Wwgl(eXe9XH%wpq` zch`V}urkL0-ydE)RkY29Ej2>BgBR)16jY8VD%gLpSugzjkl*9-TOOBQY1Fh5v5uJT zV`Y8}w}M>x6?XRHz@s6Zp{hwNIH1LqrV{WPLm_on!aK9(^o`a9Gc|5yq8bLtUTa7e z`W`h7-UEFQLKX^9oZAs$Eq*m1dF`n4!Hv)PQst`19?3ZGOG> zv*T*2wFbPqRN^svIkyWWdmEf}7;bTNBHzKc!R$^a8-rlD-6P3d#c9PViTffEw79d0 za53h5cYAs3I!6ao%;7+AuHQz1JXsYs%guIj-4=OseOdQAjQH#?V^w)N-Lte4W;R2M zs|G`(CHyk2c-zl+IJ|fXq+5#%T#TbGgln=rNnd`CeGtgOn258F2{$GToxQ+1@Oo#W zVB%IvRFj}2pqz&{lk3|<44Xo+aGH>iq`ee>7t{@Wop7AUe|ZxHSZA!w)CTsZo=SX8 zW(MF4^Qix+lM;KGe8wFDgbw-V?jSeg0!+*MH38+2aiTHn*Xy?+n4R_ZDE9TlAu)r9AXlq;)5FUHGTYx ztg$EPG@`E-Yu@;?RTD*S4|BnqDt*=9=FRLO2$V_%CH7{2YMSc;StF%!G`~RLnwW~; z=SXtS`PLF7B^Ab$d)Lt~I&8)Nflk7Zz^p(mwMq<&=cvFo2J=6g#mJJzd8Et?1gOX~ z60rufbJoo@R*-o%$W`~*nMPLx>^Q04->ZFd*&*T*2lBqq%|{r{na@A8*62N7T<~$w zXGff49jT2eF|={M#EHPDDW`j8Dd*Qwi~on}zB9+1h8xNoZ2JY0OL6>Q9EZ$cc*tx~ zR4c4L!Vj(^&lITsmA)WN`tS>#PV^$SLmBL?I~FnI)Ac87`}idomcyH6bHX1>*vWz^ z3g2)1(-9cXC=6j5=O5>M#gGV)rQX!8eV)2W$H+i!IF+lh`FX%mQ)Y5S_P7VX7`TS|V!oB(zJ^7C6UnHD* zCOj6D>v!!TKKwd3a6+BWCFt8arDSVQk7-Lgr}2?%r*SZu zoLrcwXZ4C&mv~HHB^n_7^6;1AQ=;T|+ia?3^l=`pPmRqI(n#E#$U30F9j7El_*;q?b^QI|LHw%) z*HWG^_tUOI#F+H(zvu}F_)Xv0@{nQzeh0?gz={G^C=zhHO4l@N@g{Gjk3Cku8^^Km z=yRF79=7SMNHdVX##(`7K9ooKk5`xT+Ub}aR>&U|YhwF-J?>mz{EPGYoYaP&e^1=a z<^-!`Ij{m%6yndkKkYz5+iWK;&yMK1X=QWuvYl_B`KwkQ=t)a zbMK`R6A5<2_?s5pS^W4;6?6C6^S`k36=Zet7ZO+S$3&cdS~NynXmR0DV=$7uvNHtH z6%hib{Ejigz>Y`Gfif_L7KlIg&t+=Dtjk40{!eEi7pUz}B_-5SHR);0yym^HFYjkL zTkjye{;<;%m{#8>YnLfybwAA8yR-+_oEQEj8&`ja`Qsj4O`vAr47huCb-xNllFg@QxdJ@{%!y(;5hYAa(#%IXARBt-u_?a?62z_8V$;jJQ2D5!>sQV zdFzxAQrQmVJoyJiHY7>!_=mICsfz7q;&E*N7GlAyeWbFvQCO2f74%yO@nxK-^H};{ zMz97yNdE1c89*9b^9cl~BnHm^1f9StF~(P5h0&P(CD2CzZq-;t5==}Gz<^c4n;bNm=!+}hdqlh$a;tHg3vuwi2-PN9Mwe?lh7 z051>CQh&60ukc&GPe#!HTD~z{#3E;Oj>P~a(gTfYnW@|Yk(Fp1q)b?jkIdeC?1F0g zlYA1z7C-n`5SK9zDFKF5kmG!H!Sm9VQSnf4XzM0oiTac|53qiByoS6~ERW zuF#ULRe;*p36BUid}_rC*gH6&ZzN-8ZmS}q`l&9&R!1~Vb?jT_Z~nu_Tw;1i?W+1^ z4z$6Uqr6%_;9!a+2gduiuXfJI%c-r!2{f|gMnKqEO%pB7nq^*=Je&!fS!*8T4XFaT^ZemoxA> zsi~JK6UhAwo^QTLp*uG$JxSVEDHp&0%bh5IqBNJ8^!Znmpr?`t_)G2uR^?QI;ypxi z1E7=$Ji6mQnp?u>o#*~s9wH?jH*1Cl8FP+1?-KG_THJ0f0&=p;7X)T3yFQ-f=j2G? z;VeGZiuOk#B~7>|8Pn`|BO*~TO7l?+A&%<7;eUSiayR-XES%vh99~DKG&!&r$ik$I znZ=#P#rTo^rUfG}mIy>hPrTa`dw5QquLuvoFCVksupm@9NNWZHt)+NR)FwiPcfE&t(OX@}P9 zhH0g)#WUNgh(lrZK2$efF=AsZE!pbz#+Z*wW6=2b!L9fji^`1##D%%PB!>uERoNTj z+U;=JHc9H7--Jj21yMNU<7&p*)6UrQFeDRQW55mo6RAgn`5W^~pg#t*a}{ano`v?( z`<%5p=^c%ez}5i%R3Z5Kcgz<$FIaA&p-nRjT)G?Y70Rk78vBEM8XcH)CK6T4)@LcZ zii#L;3euZg1;W`-|KU%RZf7dv=%Vm+w++px-|HYjW)rOfR6cw0~e>`ue=F* z=H07U+`hQu569|jFSZdBLh634!OX@Bj5ifP@?zG|Bkc9Ieq0U_UPqh<)&r)Ys8C`tL)pA-hnPo z$FcEW_-WV_>De$)%V`(*HHa>22I)1Xc<>pHZSS`A^a@ZPMFH^n7JlA9iiIb+VIuwy zdh5)%E1p&yLV%1>F}!$h=J+fuWcusprcTh z!RAtdc-lL|O;g!eJzNXB`yBE?(bYefMJ^___n#!ZuW$V+^cu7{-;Q72DB4ugduXv- z`|enGPwh}S1G`?^7%8M*(c^?99SU^{e{!saCzB5$FNv~LL ztFz1{qlQ|PYWNglasqQ{(Q6kmzd80HFCGpU3aG7OIBgRQ7QAh$@%$NJ3zuEIaKdNg zIYxT8&nVM^SaTePgKZ!By)miESSZ5rs}e8ZH5hC;&9IZS;-VXUU$c=t@C>J^62G55 zc$X-4F$tF+U3A2tO1iH~2U4Dh8(FD!cF2gpbHCy^@V|f){At&iHj@y)>c4^0&nXX& zL~r|_BI)7K=LGyjoT$+o#-)~uL;$S->vF2fPrU>Qu2P@}h7qD|eN_{6J(JM!VE-uW zIZx2xlr$gBUv(DcQ8_!mE~a(8-AP}5bL+tb(rxN^-Pbmf{NoxaKxVuhaiEPxwh7KG zsyuvy_NDrhZ*BYS!ico^tBC0+DK!gE*BQsXyI_=Sa%Iel{?_%+>fH|66T2lKmq7KG z`_@o4r`KM00*6Y5#bLB}owu*@Sk(?UPgt%Y_*1x`!A$PuQOA`d?$T6n_g}%#kXf)G z&V)E6-68!mls)Pi^}oT%NLs&u{UPHgV~#!=U{8t}@IpY!bIg@v2S!P~5~`7Uo&5b8 zez3PGhma|cYNoe(1|Iz)4tg%S!!tn?kdz;?@3ufP7mrjx$c1kY7@~?W4Z?;XEw@bXgvQ3Ltvf$rf znOJ*I-8#)snoP1d=}NXpFv*s~Iwn2VPp@=5R>k;0Pwl|QP@b_;58o@E%7yS)Xr)-BsX_=01d~XwcmFbkG zG+iBC0)FSc^UOpoS@-jp*b=xBVtYpqK^7n!v46%awAMk`npHp6%N1LdLxJi(-!SHC z_DSUJ1Vgva1*2{8nKc~=Cis0x{c36I z`-o`<=YR0+V@YL~eM=L1w3_lQ?0LUpNiHjz4{yILRIDt8)|f){GK%&+&feq{CvYAka?Sc;)K>1tttL`f>+L^-a9brk|n-%S13y(v{D<}675@A!e^2`lPT(`V_{^f;>`EA zM6c7nT%&`s&kikS|A@wWu-Vy&<1jUlP+mBqvgxd-iW3jwmMVB9qHgk!RjHV#?LM#T zgyX8tte~*RnoIDZbrZCZ{>IF7(&b>f=jU>iG$>di)wmYxie&V(Y(_-v{4>nRkReEGlN({rKzqvZu)q30DZc6POoX>87DHiQcc)w@__>+Y4628 zWmnDh$SzIgBYx`p7}1|Pn+AHn7wFM`&zq+o%xQkzwjy+PO3X7}K*YGJsY4gX)d((p zS&I$cHHi58?Xm``B(Z1=?BU^jqj*E`{-W-q5CQM@ z^XM-kKYKlJ+a$gWI;1GZgkC_FJoaikaDqeKO!`C*3HK`TtLgXlg5;>n9|^w(K7itB ze$~rV{^%6BFTWNP8whB*CZB2%$b~dtxDw?Sp~Vg^h)BSNmrj+ih8{z>xFu{&>}0cQ zPlME|k6%W9jpvq1eq+gEfj&k%#g&KF>L#&#xzE}p%#_YS$_@gVB4Xor?Uc4elR{m{1ih zulXdKrA6Sc1Oif)MR%B7Zqq=+Ik~TPAe5bJLqaRjZDIu`bp5C^ze9zqAgMzV*OH}t z)sN7?d79L*%_g6F`yyJ?k6f*;^}LfqTiAMOhwP-Km5M}~k}|YEZ8nygD~1D-gn~gY z`TW?yh|4tvHJ{mAjx?jCj$(}n0ortQhDi|XP z4Sxr{%^}`w>)s(PvwOQU46fT=qDWG=^Yd7`sskUiz0eq^Odd3f(8NciY{7@hmEtv` zd^v4{p^@+yj60;HX)~hdl^?ORLf`bEN8Nu@)od$Y~*}LKgccCn#_c>iOP!_Pw)VRA3D7eMyhzqy1J;uSqL?`olZMP8@ z->*LhC4m#v{%s?(J2N;4u$CO-h;O@2f}k?K74*98KQVD;ilun|NQll z`+N_LZ22e#(|u(S--XkPfQ26oD_PBfZTXE8C-;+fUSu+s0w7L;s!%oO)PYc@ zRpY#EtL|5U)1^@gU8)cdL5oYz70s`}f2gC9n}m(sJqRm*SbG1t(-ORSwM=z=`YV@d z-WL_>?K4(6)cI-9wHGTUMBqalyHM5=h?@8|QSIuW%f%tc znppE8>cE$bB#8Z!D*5NWXVRUtl{%!{(tj+TmYGm)qq;?7e^D38r;)m`c6+1rX+)tP z&1fRr+-sVXlVB^@E!N%naWV=f^8*gXDRmFI0zce1Z`yxF+7qv=Q*d9FDplBg1@PSj zv-7kEtY;MNP93^@_wn}a9l`KQ<55*D{B3&d5K7pJ9AwWc=f2cWvWpw*xv+scD^iz* z$R`ucae0|Nd|}^f5%SRX-GqhT80G;JPmyOTSSa{h@rwTz^AL3`m5VPpxA^bkFRgM7 z6(@{VW`?a*5mhw$j2=&!sE)1Zl`75~B^QO=W|xvBnmIc=ZUcb?7YkgE=IPl$M>m_T zc}=C@m}R(bd~1PRIJ4TXUNc{gV6Q)}qyQrgez*0LJ??WzTfO$}{Gf+K&_cy>#~^i< zV2zWmM5;~VT{Pvwrehd5hF>OC$xaM2KYgJ35E{Cd+IX#>H3Dl6&XjiORt~9nTx8d< z9bo7YUC&)~>h0oSZ71f(C2GLq-3Jjn$=E;VoihGWb{6!%pcyZlqX1PRIBYK`ma~J^ zQBJ{D88CmTG_hl{7&d=X$(qh}!SZt>lwbA6dT%b{DpgTC>A%2SkvyQnUrZ$yvV7p| zk(-Z)a2`f1tkBXzz3hN-;cJ-Kfz<~aO;+I?RD`me6Db;k@piB~2M%hnG!7#5j+i}t zSiYq2`G@p|pYDhvWL)~@8Kt^D{Dfpra=bYo@8l5T8KF-_wN%aVV?0f)ju?HH&Y6i( z$@=;ttzSw$lM3?VC!RthwF|Hg)b9)KF(oH_2w%NxKZx^hay?L)bXZeT-@f$Z_mB8j z0+!<2&3T%*(zI_$`Taa4>0y?+hLO%6Mg7@ql=Z+MN_L`2&QW!iHzg6q2|ko%8EQMY zrFV0Lfz?jCUcbHIhUk$<$Q9DCfaZhFJ(ko7t&$ygy+GHjX(TJjT7P2S=q*uHDht^2 zgx7RveB(p*7)%_{q0X0X)O9KBoXe|y$S?5rn;3OP_^7!SkCpz%?2ic&f;{}ItVVC= zlcOE=71VW8w~t^w#tf*7Q)ATn(pFv?C%EjBk+1f0+k)-#diRJHZ2e~;)6xUVz<6)q zDUGxjmX|xXGt93p^SBlN$;@A0eM>IPezR5W-(dirC#W8I-+Z|P+J8>-{?d_+xM;09 zTG0CicR}!{+xtF(LI0-b@T+C|OLmU6E4&&53?sa{UA?^h2-2#sfH^9vhU0oKSP)R(gS(e*%8nK$SC~ z#qgk7AKJ7@ib0#@)Ff;Q@6w1F(LpxRtzwzyyox1J(O}9C0bzmPeoqn(TTP<|9*%_7 zmEmY>Zd-ym-Whdu7<}=f0>!(N8lHc;)O=dAFqD$c(i;Y zJi~mQYw)8os}#Q-zlr2UMDDFSCAR&}bH^_ty$0*cRQXzd)xE8^?I)g4RQrKJZg1Dp ze#%*%lqxkO=FsrrpLBF&=4JU4X^)mgOnk$lICT%h`2n1G)V zp@hSqMxsh9l=(P5!p)x(L6-cJW#ZImxj=Nc#_%0s89_E zbNAPXcEjhXgr(-xxYX@7t&wCZh_J}~Hr68&AWuQ!hdGgC103`Z;ClCAwS=QRRMS<; znNnjHe``UPUmETJSiWG^F&p;$>@TN-f~_u;WoL0dV%9Rg3DT!}vYoh-lHD-->`9EU zXHu87wUA-Z0Fw|~M}1>G%X;hbv1=9A7^L1LsmvMmoc7={nYVZmv=JBRS+GWs@-8L* zVd`K}7=nv6>AyAXZ)vVdV9~Zhx#{RXLi%Kv?CQhO1XD>H0p8n(0*wBdr^d%M|9MuO%=cV`EJ?;5TaeM-G8*W!<|y)G(Nd7w7H<& zl*^mwQ9k(j+qKN5cj{5*`6-AyIRIV8bb8zH%eqH=biX6L$~Qse_O!#W>U2@bBtPmI zdifkCtYtMb7C?ObS!X~t5zf4k7wp!Og8HqJD`;e1(Rg_UaO^njuB%jYbXTL;DdFj! z;-rKBRA+Fr>+!=$J2wT~J>Q$-kcI_~+5MaYk8BHKWg?`KV}5q!%=S9L(ivWMtW+E9 z&*M3AnGN`x)p(Ld;a+-1WJ^tnuw{ur`>7YoI$bU;A$OQVXK^wBOkAH&lktj}217py>q=hl`te{YRA0XrtFt0DhxVae1LEjbG8lM)Fq zc=Cl@7-FTm8%m*#{Qu_QvR@N3+F>SI(DU{<{Ej~uO(o3FGDR!+23Hm+-3rsj%`}}t zP0SORH6UU5*@F7x(4r#pm6jYbD^vQ=$A-<{OjQzim8UteBuZEs=Xv86W{sJd(oh}< z<$H)RexxKan;)%fF25IyAAaD*B-t{geX!dfRF{l-QdG=PWYoy*c5F}!mPT?VD9F)J zSEa5^8cVt`EDLc}N6=)U=M@@<5=d_K;3&u>aT|d!=hEYOEEt4c4wOb} z{z<5DnCSCQ)y-SWa*XfDbV$5Tam$e-{7K>Xz${~iU*~jvC^;U^X!Yc&{UxWMIFWv_ zZGa$RS23H&M@xeI+zt6hnT*h2e$P&YFd>$+epq_h$nDJ(59e1x2SJS%@l{FM+epzW zyzeeys(=;bo*RM@?ynv6xPBy1@$z+|XKHUAe)t0 zDt8p?@j)v$!)ED>Neftl z3H(NzPf>mZ`c!Gz;@IzRcFj=x7DsUPYVPY$9W7e$f`}9^Is8H68I53ghV(P*?xH1{ zk)OIxqu;2i_~mh5KD44Y68WOqn>p8&tkYLwE5cJpuJmsX!c9{Hs^<94u^b7AvU0+ z;~>ULhw}R};>m*?#VuDpso>x?4ONp~$KesjtQ70c>~ReAzHYl~iggUx&95l^Q{r}P zZsYCOh-t}I0c7Nv)B&W!K<@EC=+jqIlc;h*nsgt9(1AZo>jkbL)2tf$z3#JmQ%W+( z?W7RsH;U!|0O6($j(6rox>15#XMq4M5N>odxx2+xx05-4MMAwojjB)rH!QqiIY~qA zFTuEx@pbOHs8dk3!=dgqRAjtYw&5}M1}EeO4X^|Tfo|&0K<@&viGY zPsXhR!nHOQ=TEr~b;folm_-}pi;nthDkjqK2!w<$%BaUslIPbaMALdt(|3b%t>O$Q zd_Jg8o)R_gbiI~vl+@n-!qHUUMU#cwH^WFI7Ae0r?>L1dH?7%4|-7%6Z=^8JF} zYEPL}Gl4W8ZoRl?8$&0MlCc(k*utS`iYTn=xFmIQ;=zy zE+;+;LKw7Iou(unN@TDZ6{F<)m9{nrkbt=Ck$TX13oKr){qn`xXOCyvSGzTHt9@4` z&~e0lq5H<~F<`PtJB`CW!zxH;R%9jwgRjlO?{Ta{X_~YzcT-9GPGw3*HyO5DX`f4>BB1yl@nfi z?%NXMqX!mkBh7Q*@3$Z{Mrh)UOOmh9TxKVsSci+RaJ&`)rJpt=~|NN@xIDuJ0S8Jv26zIAnq5n$# zJvT9un7M6wxla@ia4(H}sNFH5zR00IPI>P^v`sq((Hc9pvZTd@@kffOYLWdWuE8&R zPrd_&!5rXQ2Lc@U@B%Y_RaR15c#J~RL`BGhg8T1BX>YQ87!dz7cX>NJbg2x$G_nQ6 zxgK^k*ZA%$d#65NI=`9KfgCxkKJbxlWKK_S)pz0MG^3yuBr5lua4k{h?KR%{=YXzA zHb{W}Dfyg4I_u3Cc_u*MS+Ywv>2?&I)K>G!v%7mQsVFWM%Z;&^+*0mO@Ntv+T3J`T zj!$qdc}!>+vJ&D{S6`e-;RP*QXhjd;1--F^7Ky9xRF-uD-Qx$Lw3ue*9CFxl3zHKdb)~IpL?)jHqJ4 z3-**k+m<$aryM{C9vG%Fp@uo1MJ`Pc%m_=DZMeUXZL)JRTS~1sV6QB+S4m#Q+5|2UlE-pQV_PZ=XwzYB!qARB6p@^UIC+sZvdjm8pF@eebT zeiRz#TuW2)4DuI?hdeG@@Qn)z3UVmqvIp`xQNs~>#UN&Ad~A4#t|}k$bzTw4|qHvo8}qV%jM`2xSiIkDEaP(3aV`A^e+W-I6}6+z|SJbi!Wd(A>3Ex zn(um!K zz5o3=8Y-vuNOB5>!WZ`ct161*BSJjFBa5oeJkTQgJ3Nr4?A<5~u{&m{#u7uavAtp~ zx{M5vXJ}6Oo?eFpC(Q7=9csOI!vt~{aR*;iATw3n+?ItLm^nreJKrt{DbughzD4^9 z-rkB(FOndFDVqHwy?=)tf$Z0If40qTEfen4`hQNd3y?p5JURkM95-meXMv$&sB_ayIJF>@pjx~6xIpZ2Xo1*wHD2^Xz-9&5<>vkK z^@-J)GBfk{i+YyzPn<>3_m!d4x97QYofjICUsH z3Rn)ob$prn$4reAAif^ zUnWyhq7?fq=prWO^rQsNpttxU+`zvYgwpMsHtUD4Cbkg2>CLHnX<6s6 z$I&3eIv2F|OIpot8Y*_mQ+LScq3pbt^Vu%pmzz2>%v#*UU?TZnz96IwR*JYyu+N@= z2`ybN?xQa|i%F^F*8S=yMQJmkT>1;CxJ?4Q;--)ME*C-#RJ3#$cNX~gx_~xlM6Wc> z=QWSfP+atB7jWR1o*vJdRmaKN7XNbXr(NgtY>(^H665befgJ#$`IkAO zmA8)7z$b%|yY%jBrHm7jTC!?u>FEQKRR02S7AxCy`l};iJpr!`X(DFW15iu8_+Cva z?!f+Xq9xH__%>nF&(Zmz=3!ktJ#EFyRGI%iU_#oSm(vxDa%z(fJiP>Wg`s}!YEBr# z$0d(R8l}~eyXH*%`wcM)T|u>CgTsr3QZiG)tqzwtYyK)wu@Md_a)3ls?!5zsi~kAG2``k6%O^;q4$3Y&A3@v0yzJac7Bz6g{WoVkA;J=R>{^nowjGlr-oZ>f>Eymrx`b^L|Jpx`D+Mxc1tFu1&fjfrfQPIcK3}3bB zpl0T>18YgP&0LU_vx$N4tCC&$mrphIt~OkR>#vP811#9lwml*9Fdm|T#y63{I;lre zW>t!@P}@|fk>01^cE|&y7l%BzAWF@5!Qns(H&iuJ8^3)X`{S4s@v;@9*Q4F)~5~0G0m~Jh1=W)DDI8-0U_n z=O@0tfFHre1OSZX1Ky8lYAc=wgsC#^0!GYcYJkTH1bzQJO#Zs2)yl|#UrI^kZXJ)$ zX_QoaC+fQjT5BFB!lUe1@cZEK-}#`I9!3VfF9WIp{HfaR@N0CO72IWX{o|ofObHy3 zP~uS919GsOICzi{Wq63Wtf?$yP7$glZ7F|cYzSino5tPN)fWF>g6m*`KQ|9 zTV=dwReH8nok&W6?&jiF*PDOEo5&xK%mKH{LaR~aJ(Sxbj{&A~mt+oyJfi*yNN#d= zD4U(c*rYFpxAAGYSWWJkRFSrNM9|%2UkDX1nvF_wMSV9*U zLtSq$22W@4IJl5H0vS^vJ9K~{;YB->P6n>S)10EyoJGPk(|%bD#yUOmCq0ZCl3~@a zg}O!s3BCclKf#3Wf43NeE%0-|tuhg$v<71)YRHO@3Xyf^=Vw3?Sa5xi_JkrcqyPjF zaz<}xclc_*>=k?aH^rP^8}n6f{du|vR@`QF?CNZoEF3Pq>_27!YHF$Ze=JKV__x8m zOao$mXqrdsoJ}j&nv@4(nPomv3_;S18a)78sK|W}b_CSsp;$e_#RK8Td$aah$NOjE z{C|Ohd&`KsxMbf{wtZ0HSC(ZWb(&r5QI4kKinDCE7e&CRIDPhCQ@4WP2SAo{x z2d|7|6Nf*EVaYKyNatH6vOO;ls5#+{$S=dO!dW7~z4x~4m>?@3yl%lct&^G)Ls)2md5Jmt^CL-zQQ_LuVx{m85h zXR^Cfg4GVaWJ9<;HKY0>M@^$F;HfpS>z!M1CXvJBCVqz^v%d$?-1a4`Y`9y za)LlWAcsz?&xi?dbaRp8$+)c<47x9osSx#IfqKWg%?sp>Gw(H>)1#jJVYqChLtHa# zgIA@UaJRf{u%ea-qvSuv#T%3HKJpYrh2W7jD6Z?rXU4E%q-0^vK-;oR3Ji6L>?%(` zUHm(+IF2~pHdM%T;1_&o93Se=LL~UtwhCq^Bm_oTD=69g6S!2kI7s;Ky&S8L3y-t| z5ys0x$S$;ivgN<+iu%K8g4cPC&+cvJebe*@=U*IMS&I<78?YEA7pwW&VFIMP9^NYj zEWUzgpWIFc&cM*6Yw*jDl7wy78n?*P49XrL+(6VP#xpnVrVPvit)YwDcf7luVKuRr z@sHEgI-5Xs^8;hB&F@<(mlbIEd=|~t^`KBZou4A^ppxIdy7@{m#7BSDQ!E!qr;&_3 zeswIWXi>#eV){5Kk8AwMZjY!6W%2WTCFJsd0Z0|82#P)=*AL`oAUas$~$ST#i`%UeY;!UPr9hhP0fNle(UJ-B`u2-^QJ#>fN zZYi%-It08@L?|j7RAEpwJY;){ru1}>`~Y!Cc<%dIPrz-JBGf_;qFM~guL%uLvupOsek*6 zYzmK*o9xF?mn@^bG?RusYp=Qs3p^%=hz>Yo`wqwRwXNJHXTFVU(?!xGmiesZIQehf z7J1#Ug<5WTwV{EHG;?pGx0S{gOg8CNOL~Y6EyK|C+S{ytqlS%kOatO5!DZ)^lTOv5 zkd-X~JpJ$=<6*zM(#v#}3GkzWLrwEj6d_6laVpBl3F^NcrvPCd=hDO4!-ESC6Vk(K zpX*_NpHp9t{r1Cqp{(C>`LYm2RNb7BrC^?!x4 zLg;cFDkeg*2l(&IpMttNlRR`z2B=llJV+lw)fr;{F4|B00ES-ON>0a8MR{K_z zaGQl^f7aFEKjUvjNsRjhczU~eaVQ+h%RgssLqbjwG2awmS|1x+K39I)=BQ%+fkFkk z2d!)q*Y}@f9gmmuclR$AT;4z!Prl`3IO^3(*6pHA=i<4EE4O=-^Dj}4NOkQd=OAbb z{WpiG=re(e)(bwNbI+VV%A7zo!Z7K>&O(A>$fxH(8U_;<57lr?J z=e`H5+5I2HL#Q<#J=T<^4Iiw5c0NrsB3h(XzM+Cc4y*8e`yL4QCGW3!Bg{f{J$o4w zRX)=5yR|p4E|w7&1v!KYGRMFHvUmpwWd0?g2$Gjk>wdgj7UgILjM#N-&TpnR54bZp$gMq^plDzU?|MI2JV?PK7*acTf-K>1eU$lzvXC8RZ~yIBo_gA6{`BG+G9Zgt9X*Oabu%_pZF2KNXAB# z03MFDZFlu>r7xEMF&<6p9{MJ0+jk(~`^+wT5fe~Ayh2_LMP0204d?>gg{kXdZ>n*a zm6JBbi#6LUwnU+YKwc7*D3xY(7Ax$CvZ#EW>3f|+e834J6M#f*-(lf@QQIJ@j6qB1 zz497Rr}XLW!_Z4NUo$biEnkbmjo+CkpJxPC`i*-)Fb_KAHUKK6t_Cv@y0v)TbeU~A>H@`Dg=2UwDn8`8 z&A0P9yB6LgV12#s;?(3XaEm51tAvI#DMM)^hSWk=J&mcpKP^|^Kr%7q^X$)}@>MUv z#EAco@g|UEr9KqGiLcVRX%nGJ%av)03kE{oqwk0(^p1F_DE}dzEF=pr9t3%hLT3NL zi-)LTY0~2(HJw&oAKV(fuxxoXR@KxFwOk8sE&!Snc(MREKVWWsZ;CFtR-f*lTB9L| z_c#neyvH+>HgYR##p%Nj(f))WySmaZ0l*HvLZvU~xn&4XVEJ-Qz@F4^kCb-6FKo)@ zghPrpRGu(^89WF3$W2eSPXEgZ&-a3myhk-QD3#Vj;aXxk9B|GAQ(# zA^!gCOU=sWKV|0xhVWfX#dJcsISj6GF|~ff`DbA5A4w=WaJo%LKIqL89$(qUCm8>B zprWCUV3wUS+fr2_A{_}ijBEcI3P}`YC2E5>Ffm9Kasv2%p5j#Zo0AqY1EtsLy-^KO zB|-A-isHi)jkhVON}$iXrF;i(HV?l4W4y4=An@(;)IrVj&7WDFM_g)WK2&|9@<~LL`9eh^22;HC*gP%Qt9%`Y11C98>-UDwjX95W*8TBW2AG>w)~)Vtls1An-izJK#Z!*5$K92E2rr z1yQCz01r|b<1CY<$48D5XR&G8Gji+_v?|@b&+e=oCOH7MXZyT(9CAM_3d45xml|BA z13$HauZtp7+|bz`tZ^?z{MlyJqM1w@z6f@JgQ9OQ6Kq=cUI>F1x4`eN9d@f7dZ|`=2RxgpruC|+PgP4mLk*JhE5wU{?!mH^<-Mic zFPMFfCC59r5)FQWm04_twEUdjn0z@}-CID(rst>hFn5v<^dM6z_{b8KvKYVE-iX2!tC!tPrf1W-a%f5HQ zTi5V9w^MHBW#HJSOwQS-Mg_nxKmc#-BT|~EI-M9PA?Z&xw*L_xeX!{^B(KE^orfl= z6UaY#?uCiB(!5I;+aw-_&_eU~tJLM+S-Yec!Ks4r1|g+=s8sqO2RP9Wxa3|K8|ANJz@)8fEj^V)Gf@&Z&HGy>qD_2N;XdU zFkAL-1yHD$81nNcB3=xT@`Hr(ecs?4r`v2y;e=LR(x{Xp5+tU@A(n+Hz@5ed&hX?m zNE8nKS<&VvkLs5m)zT)F^gU-(bm7hG#DaAWhWnR&mPYRXLlARHY+t>@1 ze7s+J@l&jV0zH2B7Ue5n^{hv1wO0qD9dEhddJQ9MVYAhXtS^CwsFj(TXl*W$q_xyNSN|EaqZK(EhLNhSF(!z`+2)3& zHe^9)gdgx0_wybMyQ14%)&5HPwWsMPidn_S57Q-e`Jj?|FjTUEBKf3>dxQG@j{S_B zGtCZ_3TKG(O<7b3+~;Y%y*qz}m{tAqHrWq+HT3sGZTD}`mL{2toBREYde?4aMo-x} zkA?x=e}>kG@%V}49LP})g4q-a!g=9aQ&x0PJ*cl!f$hx+uE{1?v0YFS{=OSSNWb1P zxbJ(}bqS-38{D8eCop1|ABqp`K?>wOrVH{}IRaQ~Ne-G6+KZZ!A#u*3Z2{GJM1Yuj z6}Z(h0*cYsmu1lEza9f=EH95L`LkFL()lPD@^M-1fbQ@8XhNL$s0RRskB-4gzDSzo zgimN3SZB{9T@7>l6`N;JHeF$QMw7nj^h}bFrVWkD?$Kz@Xly2%ZM{luJf>fY zpt0DJm?Vz*i+!~W6WPfcykoe|0?3YJcSk)5cD+ho!;4J*VOs~+X)VM@V?%U5Hx-t# zQpH;QnCf6}QrKRe2qUG!Hft8$_EOv`fwm;u=jkWxud+aXTxx?8xkZ)|>P~mvnGgdsJuZP7LY}G#he% z6b3|hu@Bn{6}2NF&p+M@!x-h4MP!{z-iA~BfG;iswfu6%S9afI&nIHpOw3$#0d{-}cV2@aZJs z<8j{gaF}Nqs!55#@G>3D1!iZml+*n=vh`t6XC7IhT+O1jXo|OL0;Olh4 z1ZmURMgNcL4qrkDK6cn_K*4^JtATy(Vd@bR=Dtw= zOVHL>9JWociZsJMVj3vs9MMI-8SD4utD-_X8oWz#%U?M;;2jt;);%p%(9@zbBr@!h97h&w zwQNR9JfNQYehr3YqiN)!bN%%^VZ5y}G{2+qlqV`+@AvFHS20>|d)MK)q_M@B-S#7( zhbM8P-w;~?v=pEz1q4kXZ#Yv20Z%>XkJ#CNp4p7zbZfox?#F^i730vi%X$={6BHbt zpUlGJco-A+x0A^?_o&QksuZg>1Iiy?_X;X4bHy-2*}rF-+Q|}j%?*nmu?(;LU}3ep zK$ei%xVhAv1A^?JsSBRVZ{I9|94t0`B`e!yoaAWrr<@oPX6waNQIn)pQ~O)8J7fz# z+gh2PNAqM+=f5~VQG%a(f~vje7-k#?s-#FPF}p9J)dJSD%`P!aA)dW1otn>g9X`p)EH@C85ap#79TulMiY z==;zq5Y6Tj_@-_T%#s{5ZY>-spR>JCr-#*O{R@dYl&-qBV5t22bMV^oT*)rHly+Wa zmDS}6lxaphrjWyHkva!sQAGFT$MPwmw-F~_E}5NBxd3Y=#fiXm@Xrw5o4sH{wo{&F zV$S)+%~Ye0o>i^A4A#&3^OGY2m0v~6P`HP|%8^}r7NyidcQ0oF6$Cc>0gbVWdck#7 zh2$Dw@}4{V8eRO9z&Y67W8$RQ)<<&2`gACJ_Gr4a1j&)fUJGaubpIh)4~7L1TXM3}$W- zD-)e(V|UIvr0k>?ClFaj_cFHN{6MZA(`4S#G5h9Lj;|N&Of?uG724 z>!r|&L$zjlk`E|C0k%zKcckB8+$cq|Af

 + ); + } + + return ( +
+
+
+ {files.map((file, index) => ( + handleItemClick(index)} + onDoubleClick={() => handleItemDoubleClick(file)} + /> + ))} +
+
+ + {selectedFile && ( +
+ +
+ )} + + !open && setPreviewFile(null)} + /> +
+ ); +} diff --git a/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx new file mode 100644 index 000000000..75efc2eb1 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx @@ -0,0 +1,57 @@ +import { cn } from "../designSystem/cn"; +import { FilePreview } from "./FilePreview"; +import type { GalleryFile } from "./types"; + +interface FileGalleryItemProps { + file: GalleryFile; + isSelected: boolean; + onClick: () => void; + onDoubleClick: () => void; +} + +export function FileGalleryItem({ + file, + isSelected, + onClick, + onDoubleClick, +}: FileGalleryItemProps) { + // Calculate aspect ratio for masonry layout + const hasValidDimensions = + file.metadata.width > 0 && file.metadata.height > 0; + const aspectRatio = hasValidDimensions + ? file.metadata.width / file.metadata.height + : 1; + + return ( + + ); +} diff --git a/packages/ui/spa/components/FileGallery/FilePreview.tsx b/packages/ui/spa/components/FileGallery/FilePreview.tsx new file mode 100644 index 000000000..0ab5b01a6 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FilePreview.tsx @@ -0,0 +1,80 @@ +import { File, FileAudio, FileText, FileVideo } from "lucide-react"; +import { cn } from "../designSystem/cn"; +import type { GalleryFile } from "./types"; + +interface FilePreviewProps { + file: GalleryFile; + className?: string; +} + +function getMimeCategory(mimeType: string): string { + const [category] = mimeType.split("/"); + return category; +} + +export function FilePreview({ file, className }: FilePreviewProps) { + const category = getMimeCategory(file.metadata.mimeType); + + if (category === "image") { + return ( + {file.filename} + ); + } + + if (category === "video") { + return ( +
+
+ ); + } + + if (category === "audio") { + return ( +
+ +
+ ); + } + + if (category === "text" || file.metadata.mimeType === "application/json") { + return ( +
+ +
+ ); + } + + return ( +
+ +
+ ); +} diff --git a/packages/ui/spa/components/FileGallery/FilePreviewModal.tsx b/packages/ui/spa/components/FileGallery/FilePreviewModal.tsx new file mode 100644 index 000000000..d9a847c66 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FilePreviewModal.tsx @@ -0,0 +1,83 @@ +import { Dialog, DialogContent, DialogTitle } from "../designSystem/dialog"; +import type { GalleryFile } from "./types"; + +interface FilePreviewModalProps { + file: GalleryFile | null; + open: boolean; + onOpenChange: (open: boolean) => void; +} + +function getMimeCategory(mimeType: string): string { + const [category] = mimeType.split("/"); + return category; +} + +export function FilePreviewModal({ + file, + open, + onOpenChange, +}: FilePreviewModalProps) { + if (!file) return null; + + const category = getMimeCategory(file.metadata.mimeType); + + return ( + + + {file.filename} +
+ {category === "image" && ( + {file.filename} + )} + {category === "video" && ( + + )} + {category === "audio" && ( +
+

{file.filename}

+ +
+ )} + {category !== "image" && + category !== "video" && + category !== "audio" && ( +
+

+ {file.filename} +

+

+ Preview not available for this file type +

+
+ )} +
+
+

{file.filename}

+

+ {file.folder} • {file.metadata.mimeType} + {file.metadata.width > 0 && + ` • ${file.metadata.width}×${file.metadata.height}px`} +

+
+ + + ); +} diff --git a/packages/ui/spa/components/FileGallery/FileProperties.tsx b/packages/ui/spa/components/FileGallery/FileProperties.tsx new file mode 100644 index 000000000..4c2961c77 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FileProperties.tsx @@ -0,0 +1,112 @@ +import * as React from "react"; +import { cn } from "../designSystem/cn"; +import { Input } from "../designSystem/input"; +import type { GalleryFile } from "./types"; + +interface FilePropertiesProps { + file: GalleryFile; + fileIndex: number; + onFileRename?: (index: number, newFilename: string) => void; + className?: string; +} + +export function FileProperties({ + file, + fileIndex, + onFileRename, + className, +}: FilePropertiesProps) { + const [isEditing, setIsEditing] = React.useState(false); + const [editedFilename, setEditedFilename] = React.useState(file.filename); + + React.useEffect(() => { + setEditedFilename(file.filename); + setIsEditing(false); + }, [file.filename]); + + const handleSave = () => { + if (editedFilename.trim() && editedFilename !== file.filename) { + onFileRename?.(fileIndex, editedFilename.trim()); + } + setIsEditing(false); + }; + + const handleKeyDown = (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + handleSave(); + } else if (e.key === "Escape") { + setEditedFilename(file.filename); + setIsEditing(false); + } + }; + + return ( +
+

Properties

+ +
+
+ + {isEditing ? ( + setEditedFilename(e.target.value)} + onBlur={handleSave} + onKeyDown={handleKeyDown} + autoFocus + className="h-8 text-sm" + /> + ) : ( + + )} +
+ +
+ +

+ {file.folder} +

+
+ +
+ +

{file.metadata.mimeType}

+
+ + {(file.metadata.width > 0 || file.metadata.height > 0) && ( +
+ +

+ {file.metadata.width} × {file.metadata.height} px +

+
+ )} +
+
+ ); +} diff --git a/packages/ui/spa/components/FileGallery/index.ts b/packages/ui/spa/components/FileGallery/index.ts new file mode 100644 index 000000000..cd73f141e --- /dev/null +++ b/packages/ui/spa/components/FileGallery/index.ts @@ -0,0 +1,6 @@ +export { FileGallery } from "./FileGallery"; +export { FileGalleryItem } from "./FileGalleryItem"; +export { FilePreview } from "./FilePreview"; +export { FilePreviewModal } from "./FilePreviewModal"; +export { FileProperties } from "./FileProperties"; +export type { FileGalleryProps, FileMetadata, GalleryFile } from "./types"; diff --git a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx new file mode 100644 index 000000000..9edfc81d7 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx @@ -0,0 +1,153 @@ +import type { Meta, StoryObj } from "@storybook/react"; +import { useState } from "react"; +import { FileGallery } from "../FileGallery"; +import type { GalleryFile } from "../types"; + +const meta: Meta = { + title: "Components/FileGallery", + component: FileGallery, + parameters: { + layout: "padded", + }, + tags: ["autodocs"], +}; + +export default meta; +type Story = StoryObj; + +const imageFiles: GalleryFile[] = [ + { + url: "/sample-image-1.jpg", + filename: "landscape.jpg", + folder: "/images/photos", + metadata: { + width: 800, + height: 600, + mimeType: "image/jpeg", + }, + }, + { + url: "/sample-image-2.jpg", + filename: "portrait.jpg", + folder: "/images/photos", + metadata: { + width: 600, + height: 800, + mimeType: "image/jpeg", + }, + }, + { + url: "/sample-image-3.jpg", + filename: "wide-shot.jpg", + folder: "/images/banners", + metadata: { + width: 1200, + height: 800, + mimeType: "image/jpeg", + }, + }, +]; + +const mixedFiles: GalleryFile[] = [ + ...imageFiles, + { + url: "/sample-video.mp4", + filename: "demo-video.mp4", + folder: "/videos", + metadata: { + width: 320, + height: 176, + mimeType: "video/mp4", + }, + }, + { + url: "#", + filename: "background-music.mp3", + folder: "/audio", + metadata: { + width: 0, + height: 0, + mimeType: "audio/mpeg", + }, + }, + { + url: "#", + filename: "config.json", + folder: "/data", + metadata: { + width: 0, + height: 0, + mimeType: "application/json", + }, + }, + { + url: "#", + filename: "readme.txt", + folder: "/docs", + metadata: { + width: 0, + height: 0, + mimeType: "text/plain", + }, + }, + { + url: "#", + filename: "archive.zip", + folder: "/downloads", + metadata: { + width: 0, + height: 0, + mimeType: "application/zip", + }, + }, +]; + +export const Empty: Story = { + render: () => , +}; + +export const ImagesOnly: Story = { + render: () => , +}; + +export const MixedMedia: Story = { + render: () => , +}; + +export const WithRenameHandler: Story = { + render: function Render() { + const [files, setFiles] = useState(imageFiles); + + const handleRename = (index: number, newFilename: string) => { + setFiles((prev) => + prev.map((file, i) => + i === index ? { ...file, filename: newFilename } : file, + ), + ); + }; + + return ; + }, +}; + +export const SingleFile: Story = { + render: () => , +}; + +export const ManyFiles: Story = { + render: () => ( + ({ + ...f, + filename: `copy-${i + 1}-${f.filename}`, + })), + ...imageFiles.map((f, i) => ({ + ...f, + filename: `backup-${i + 1}-${f.filename}`, + })), + ]} + /> + ), +}; diff --git a/packages/ui/spa/components/FileGallery/types.ts b/packages/ui/spa/components/FileGallery/types.ts new file mode 100644 index 000000000..37bb52215 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/types.ts @@ -0,0 +1,18 @@ +export interface FileMetadata { + width: number; + height: number; + mimeType: string; +} + +export interface GalleryFile { + url: string; + filename: string; + folder: string; + metadata: FileMetadata; +} + +export interface FileGalleryProps { + files: GalleryFile[]; + onFileRename?: (index: number, newFilename: string) => void; + className?: string; +} From 1ea7952fb3ae34cc04ee70561966828d5f1f257c Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 5 Feb 2026 19:00:27 +0100 Subject: [PATCH 03/32] Update gallery components --- examples/next/content/media.val.ts | 18 ++ packages/core/src/schema/images.test.ts | 1 - packages/ui/package.json | 5 +- .../components/FileGallery/FileGallery.tsx | 261 +++++++++++++++--- .../FileGallery/FileGalleryItem.tsx | 46 ++- .../FileGallery/FileGalleryListView.tsx | 168 +++++++++++ .../components/FileGallery/FilePreview.tsx | 2 +- .../components/FileGallery/FileProperties.tsx | 103 ++++++- .../FileGallery/FilePropertiesModal.tsx | 229 +++++++++++++++ .../components/FileGallery/FilenameInput.tsx | 122 ++++++++ .../ui/spa/components/FileGallery/index.ts | 14 +- .../stories/FileGallery.stories.tsx | 174 ++++++++++++ .../stories/FileProperties.stories.tsx | 163 +++++++++++ .../stories/FilenameInput.stories.tsx | 90 ++++++ .../ui/spa/components/FileGallery/types.ts | 14 + pnpm-lock.yaml | 27 +- 16 files changed, 1357 insertions(+), 80 deletions(-) create mode 100644 examples/next/content/media.val.ts create mode 100644 packages/ui/spa/components/FileGallery/FileGalleryListView.tsx create mode 100644 packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx create mode 100644 packages/ui/spa/components/FileGallery/FilenameInput.tsx create mode 100644 packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx create mode 100644 packages/ui/spa/components/FileGallery/stories/FilenameInput.stories.tsx diff --git a/examples/next/content/media.val.ts b/examples/next/content/media.val.ts new file mode 100644 index 000000000..4b507e311 --- /dev/null +++ b/examples/next/content/media.val.ts @@ -0,0 +1,18 @@ +import { c, s } from "../val.config"; + +export default c.define( + "/content/media.val.ts", + s.images({ + accept: "image/webp", + directory: "/public/val/images", + alt: s.string().minLength(4), + }), + { + "/public/val/images/foo.webp": { + width: 800, + height: 600, + mimeType: "image/webp", + alt: "An example image", + }, + }, +); diff --git a/packages/core/src/schema/images.test.ts b/packages/core/src/schema/images.test.ts index 2b4328e3c..4d4679eeb 100644 --- a/packages/core/src/schema/images.test.ts +++ b/packages/core/src/schema/images.test.ts @@ -1,7 +1,6 @@ import { SourcePath } from "../val"; import { images, ImagesEntryMetadata } from "./images"; import { string } from "./string"; -import { record } from "./record"; describe("ImagesSchema", () => { describe("assert", () => { diff --git a/packages/ui/package.json b/packages/ui/package.json index d360e392b..8918350a2 100644 --- a/packages/ui/package.json +++ b/packages/ui/package.json @@ -176,5 +176,8 @@ "files": [ "dist", "server" - ] + ], + "dependencies": { + "@tanstack/react-virtual": "^3.13.18" + } } diff --git a/packages/ui/spa/components/FileGallery/FileGallery.tsx b/packages/ui/spa/components/FileGallery/FileGallery.tsx index 98124da62..716d30bd1 100644 --- a/packages/ui/spa/components/FileGallery/FileGallery.tsx +++ b/packages/ui/spa/components/FileGallery/FileGallery.tsx @@ -1,40 +1,105 @@ import * as React from "react"; -import { FolderOpen } from "lucide-react"; +import { FolderOpen, Grid, LayoutGrid, List, Search } from "lucide-react"; import { cn } from "../designSystem/cn"; +import { Input } from "../designSystem/input"; +import { Skeleton } from "../designSystem/skeleton"; import { FileGalleryItem } from "./FileGalleryItem"; -import { FileProperties } from "./FileProperties"; -import { FilePreviewModal } from "./FilePreviewModal"; -import type { FileGalleryProps, GalleryFile } from "./types"; +import { FileGalleryListView } from "./FileGalleryListView"; +import { FilePropertiesModal } from "./FilePropertiesModal"; +import type { + FileGalleryProps, + SortDirection, + SortField, + ViewMode, +} from "./types"; export function FileGallery({ files, onFileRename, + onAltTextChange, className, + defaultViewMode = "masonry", + showSearch = true, + imageMode = false, + loading = false, + disabled = false, }: FileGalleryProps) { const [selectedIndex, setSelectedIndex] = React.useState(null); - const [previewFile, setPreviewFile] = React.useState( - null, + const [isPropertiesOpen, setIsPropertiesOpen] = React.useState(false); + const [viewMode, setViewMode] = React.useState(defaultViewMode); + const [searchQuery, setSearchQuery] = React.useState(""); + const [sortField, setSortField] = React.useState("name"); + const [sortDirection, setSortDirection] = + React.useState("asc"); + + // Filter files based on search query + const filteredFiles = React.useMemo(() => { + let result = files; + + // Apply search filter + if (searchQuery.trim()) { + const query = searchQuery.toLowerCase(); + result = result.filter((file) => + file.filename.toLowerCase().includes(query), + ); + } + + // Apply sorting for list view + if (viewMode === "list") { + result = [...result].sort((a, b) => { + let comparison = 0; + + switch (sortField) { + case "name": + comparison = a.filename.localeCompare(b.filename); + break; + case "type": + comparison = a.metadata.mimeType.localeCompare(b.metadata.mimeType); + break; + } + + return sortDirection === "asc" ? comparison : -comparison; + }); + } + + return result; + }, [files, searchQuery, viewMode, sortField, sortDirection]); + + // Map filtered index back to original index for selection + const getOriginalIndex = React.useCallback( + (filteredIndex: number) => { + const filteredFile = filteredFiles[filteredIndex]; + return files.findIndex( + (f) => + f.folder === filteredFile.folder && + f.filename === filteredFile.filename, + ); + }, + [files, filteredFiles], ); + const handleSort = (field: SortField) => { + if (sortField === field) { + setSortDirection((prev) => (prev === "asc" ? "desc" : "asc")); + } else { + setSortField(field); + setSortDirection("asc"); + } + }; + const selectedFile = selectedIndex !== null ? (files[selectedIndex] ?? null) : null; - const handleItemClick = (index: number) => { - setSelectedIndex(selectedIndex === index ? null : index); + const handleItemClick = (filteredIndex: number) => { + const originalIndex = getOriginalIndex(filteredIndex); + setSelectedIndex(originalIndex); + setIsPropertiesOpen(true); }; - const handleItemDoubleClick = (file: GalleryFile) => { - setPreviewFile(file); - }; - - if (files.length === 0) { - return ( -
+ // Empty state content - shown inside the main layout to preserve toolbar + const emptyContent = ( +
+

No files

@@ -43,39 +108,145 @@ export function FileGallery({

- ); - } +
+ ); + + // Loading skeleton content + const loadingContent = ( +
+ {Array.from({ length: 24 }).map((_, i) => ( +
+
+ +
+ +
+
+
+ ))} +
+ ); return ( -
-
-
- {files.map((file, index) => ( - handleItemClick(index)} - onDoubleClick={() => handleItemDoubleClick(file)} +
+ {/* Toolbar */} +
+ {showSearch && ( +
+ + setSearchQuery(e.target.value)} + className="pl-9 h-8" /> - ))} +
+ )} +
+ + +
- {selectedFile && ( -
- + {loading ? ( + loadingContent + ) : files.length === 0 ? ( + emptyContent + ) : filteredFiles.length === 0 ? ( +
+ +

+ No files match "{searchQuery}" +

+
+ ) : viewMode === "masonry" ? ( +
+ {filteredFiles.map((file, index) => ( + handleItemClick(index)} + viewMode={viewMode} + imageMode={imageMode} + /> + ))} +
+ ) : viewMode === "grid" ? ( +
+ {filteredFiles.map((file, index) => ( + handleItemClick(index)} + viewMode={viewMode} + imageMode={imageMode} + /> + ))} +
+ ) : ( + -
- )} + )} +
- !open && setPreviewFile(null)} +
); diff --git a/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx index 75efc2eb1..f8e7c9a3f 100644 --- a/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx +++ b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx @@ -1,19 +1,19 @@ import { cn } from "../designSystem/cn"; import { FilePreview } from "./FilePreview"; -import type { GalleryFile } from "./types"; +import type { GalleryFile, ViewMode } from "./types"; interface FileGalleryItemProps { file: GalleryFile; - isSelected: boolean; onClick: () => void; - onDoubleClick: () => void; + viewMode: ViewMode; + imageMode?: boolean; } export function FileGalleryItem({ file, - isSelected, onClick, - onDoubleClick, + viewMode, + imageMode, }: FileGalleryItemProps) { // Calculate aspect ratio for masonry layout const hasValidDimensions = @@ -22,24 +22,26 @@ export function FileGalleryItem({ ? file.metadata.width / file.metadata.height : 1; - return ( + const hasErrors = file.validationErrors && file.validationErrors.length > 0; + + const buttonContent = ( ); + + if (viewMode === "masonry") { + return
{buttonContent}
; + } + + return buttonContent; } diff --git a/packages/ui/spa/components/FileGallery/FileGalleryListView.tsx b/packages/ui/spa/components/FileGallery/FileGalleryListView.tsx new file mode 100644 index 000000000..0b14f3a8b --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FileGalleryListView.tsx @@ -0,0 +1,168 @@ +import * as React from "react"; +import { useVirtualizer } from "@tanstack/react-virtual"; +import { ArrowDown, ArrowUp, ArrowUpDown } from "lucide-react"; +import { cn } from "../designSystem/cn"; +import { FilePreview } from "./FilePreview"; +import type { GalleryFile, SortDirection, SortField } from "./types"; + +interface FileGalleryListViewProps { + files: GalleryFile[]; + onItemClick: (index: number) => void; + sortField: SortField; + sortDirection: SortDirection; + onSort: (field: SortField) => void; +} + +const ROW_HEIGHT = 48; + +function SortIcon({ + field, + currentField, + direction, +}: { + field: SortField; + currentField: SortField; + direction: SortDirection; +}) { + if (field !== currentField) { + return ; + } + return direction === "asc" ? ( + + ) : ( + + ); +} + +function formatMimeType(mimeType: string): string { + // Show a simplified version, e.g., "JPEG" instead of "image/jpeg" + const [, subtype] = mimeType.split("/"); + return subtype?.toUpperCase() ?? mimeType; +} + +export function FileGalleryListView({ + files, + onItemClick, + sortField, + sortDirection, + onSort, +}: FileGalleryListViewProps) { + const parentRef = React.useRef(null); + + const rowVirtualizer = useVirtualizer({ + count: files.length, + getScrollElement: () => parentRef.current, + estimateSize: () => ROW_HEIGHT, + overscan: 10, + }); + + // Grid template: icon(56px) | name(1fr) | type(96px) | folder(192px) + const gridCols = "grid-cols-[56px_1fr_96px_192px]"; + + return ( +
+ {/* Header */} +
+
+
+
+ +
+
+ +
+
Folder
+
+
+ + {/* Virtualized body */} +
+
+ {rowVirtualizer.getVirtualItems().map((virtualRow) => { + const file = files[virtualRow.index]; + const hasErrors = + file.validationErrors && file.validationErrors.length > 0; + + return ( +
onItemClick(virtualRow.index)} + className={cn( + "absolute left-0 top-0 grid w-full cursor-pointer border-b transition-colors", + gridCols, + hasErrors + ? "border-destructive/50 bg-destructive/5 hover:bg-destructive/10" + : "border-border-secondary hover:bg-bg-secondary", + )} + style={{ + transform: `translateY(${virtualRow.start}px)`, + }} + title={ + hasErrors ? file.validationErrors!.join(", ") : undefined + } + > +
+
+ +
+
+
+ + {file.filename} + +
+
+ + {formatMimeType(file.metadata.mimeType)} + +
+
+ + {file.folder} + +
+
+ ); + })} +
+
+
+ ); +} diff --git a/packages/ui/spa/components/FileGallery/FilePreview.tsx b/packages/ui/spa/components/FileGallery/FilePreview.tsx index 0ab5b01a6..26423d15f 100644 --- a/packages/ui/spa/components/FileGallery/FilePreview.tsx +++ b/packages/ui/spa/components/FileGallery/FilePreview.tsx @@ -19,7 +19,7 @@ export function FilePreview({ file, className }: FilePreviewProps) { return ( {file.filename} ); diff --git a/packages/ui/spa/components/FileGallery/FileProperties.tsx b/packages/ui/spa/components/FileGallery/FileProperties.tsx index 4c2961c77..dd65c04a9 100644 --- a/packages/ui/spa/components/FileGallery/FileProperties.tsx +++ b/packages/ui/spa/components/FileGallery/FileProperties.tsx @@ -7,6 +7,8 @@ interface FilePropertiesProps { file: GalleryFile; fileIndex: number; onFileRename?: (index: number, newFilename: string) => void; + onAltTextChange?: (index: number, newAltText: string) => void; + imageMode?: boolean; className?: string; } @@ -14,32 +16,64 @@ export function FileProperties({ file, fileIndex, onFileRename, + onAltTextChange, + imageMode, className, }: FilePropertiesProps) { - const [isEditing, setIsEditing] = React.useState(false); + const [isEditingFilename, setIsEditingFilename] = React.useState(false); const [editedFilename, setEditedFilename] = React.useState(file.filename); + const [isEditingAlt, setIsEditingAlt] = React.useState(false); + const [editedAlt, setEditedAlt] = React.useState(file.metadata.alt ?? ""); React.useEffect(() => { setEditedFilename(file.filename); - setIsEditing(false); - }, [file.filename]); + setIsEditingFilename(false); + setEditedAlt(file.metadata.alt ?? ""); + setIsEditingAlt(false); + }, [file.filename, file.metadata.alt]); - const handleSave = () => { + const handleSaveFilename = () => { if (editedFilename.trim() && editedFilename !== file.filename) { onFileRename?.(fileIndex, editedFilename.trim()); } - setIsEditing(false); + setIsEditingFilename(false); }; - const handleKeyDown = (e: React.KeyboardEvent) => { + const handleSaveAlt = () => { + if (editedAlt !== (file.metadata.alt ?? "")) { + onAltTextChange?.(fileIndex, editedAlt); + } + setIsEditingAlt(false); + }; + + const handleFilenameKeyDown = (e: React.KeyboardEvent) => { if (e.key === "Enter") { - handleSave(); + handleSaveFilename(); } else if (e.key === "Escape") { setEditedFilename(file.filename); - setIsEditing(false); + setIsEditingFilename(false); } }; + const handleAltKeyDown = (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + handleSaveAlt(); + } else if (e.key === "Escape") { + setEditedAlt(file.metadata.alt ?? ""); + setIsEditingAlt(false); + } + }; + + const isImage = file.metadata.mimeType.startsWith("image/"); + + // Format date for display + const formattedDate = file.createdAt + ? new Intl.DateTimeFormat(undefined, { + dateStyle: "medium", + timeStyle: "short", + }).format(file.createdAt) + : null; + return (
Filename - {isEditing ? ( + {isEditingFilename ? ( setEditedFilename(e.target.value)} - onBlur={handleSave} - onKeyDown={handleKeyDown} + onBlur={handleSaveFilename} + onKeyDown={handleFilenameKeyDown} autoFocus className="h-8 text-sm" /> ) : (
+ {imageMode && isImage && ( +
+ + {isEditingAlt ? ( + setEditedAlt(e.target.value)} + onBlur={handleSaveAlt} + onKeyDown={handleAltKeyDown} + autoFocus + placeholder="Describe this image..." + className="h-8 text-sm" + /> + ) : ( + + )} +
+ )} +
)} + + {formattedDate && ( +
+ +

{formattedDate}

+
+ )}
); diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx new file mode 100644 index 000000000..a5b89f220 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -0,0 +1,229 @@ +import * as React from "react"; +import { Check, ExternalLink, Pencil } from "lucide-react"; +import { + Dialog, + DialogContent, + DialogHeader, + DialogTitle, +} from "../designSystem/dialog"; +import { cn } from "../designSystem/cn"; +import { Input } from "../designSystem/input"; +import { FilePreview } from "./FilePreview"; +import { FilenameInput } from "./FilenameInput"; +import type { GalleryFile } from "./types"; + +interface FilePropertiesModalProps { + file: GalleryFile | null; + fileIndex: number | null; + open: boolean; + onOpenChange: (open: boolean) => void; + onFileRename?: (index: number, newFilename: string) => void; + onAltTextChange?: (index: number, newAltText: string) => void; + imageMode?: boolean; + loading?: boolean; + disabled?: boolean; +} + +export function FilePropertiesModal({ + file, + fileIndex, + open, + onOpenChange, + onFileRename, + onAltTextChange, + imageMode, + loading, + disabled, +}: FilePropertiesModalProps) { + const [isEditingAlt, setIsEditingAlt] = React.useState(false); + const [editedAlt, setEditedAlt] = React.useState(""); + + React.useEffect(() => { + if (file) { + setEditedAlt(file.metadata.alt ?? ""); + setIsEditingAlt(false); + } + }, [file]); + + if (!file || fileIndex === null) return null; + + const handleFilenameChange = (newFilename: string) => { + onFileRename?.(fileIndex, newFilename); + }; + + const handleSaveAlt = () => { + if (editedAlt !== (file.metadata.alt ?? "")) { + onAltTextChange?.(fileIndex, editedAlt); + } + setIsEditingAlt(false); + }; + + const handleAltKeyDown = (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + handleSaveAlt(); + } else if (e.key === "Escape") { + setEditedAlt(file.metadata.alt ?? ""); + setIsEditingAlt(false); + } + }; + + const handleOpenInNewTab = () => { + window.open(file.url, "_blank", "noopener,noreferrer"); + }; + + const isImage = file.metadata.mimeType.startsWith("image/"); + + return ( + + + + File Properties + + +
+ {/* Preview */} +
+
+ +
+
+ + {/* Properties */} +
+ {/* Filename */} + {onFileRename && ( +
+ + +
+ )} + + {/* Alt Text (only for images in imageMode) */} + {imageMode && isImage && onAltTextChange && ( +
+ + {isEditingAlt ? ( +
+ setEditedAlt(e.target.value)} + onKeyDown={handleAltKeyDown} + autoFocus + placeholder="Describe this image..." + className="h-8 flex-1 text-sm" + /> + +
+ ) : ( +
+ + {file.metadata.alt || "No alt text"} + + +
+ )} +
+ )} + + {/* Metadata grid */} +
+
+ + Folder + + + {file.folder} + +
+ +
+ + Type + + + {file.metadata.mimeType} + +
+ + {(file.metadata.width > 0 || file.metadata.height > 0) && ( +
+ + Dimensions + + + {file.metadata.width} × {file.metadata.height} px + +
+ )} +
+ + {/* Validation errors */} + {file.validationErrors && file.validationErrors.length > 0 && ( +
+ + Validation Errors + +
    + {file.validationErrors.map((error, i) => ( +
  • {error}
    • + ))} +
+
+ )} +
+
+ + {/* Actions */} +
+ +
+ + + ); +} diff --git a/packages/ui/spa/components/FileGallery/FilenameInput.tsx b/packages/ui/spa/components/FileGallery/FilenameInput.tsx new file mode 100644 index 000000000..433743ae7 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FilenameInput.tsx @@ -0,0 +1,122 @@ +import * as React from "react"; +import { Check, Pencil, X } from "lucide-react"; +import { cn } from "../designSystem/cn"; +import { Input } from "../designSystem/input"; + +interface FilenameInputProps { + filename: string; + onSave: (newFilename: string) => void; + disabled?: boolean; + className?: string; +} + +/** + * Splits a filename into name and extension. + * E.g., "photo.jpg" -> ["photo", ".jpg"] + * E.g., "archive.tar.gz" -> ["archive.tar", ".gz"] + * E.g., "README" -> ["README", ""] + */ +function splitFilename(filename: string): [string, string] { + const lastDotIndex = filename.lastIndexOf("."); + if (lastDotIndex <= 0) { + // No extension or starts with dot (hidden file) + return [filename, ""]; + } + return [filename.slice(0, lastDotIndex), filename.slice(lastDotIndex)]; +} + +export function FilenameInput({ + filename, + onSave, + disabled = false, + className, +}: FilenameInputProps) { + const [isEditing, setIsEditing] = React.useState(false); + const [name, extension] = splitFilename(filename); + const [editedName, setEditedName] = React.useState(name); + + React.useEffect(() => { + const [newName] = splitFilename(filename); + setEditedName(newName); + setIsEditing(false); + }, [filename]); + + const handleSave = () => { + const trimmedName = editedName.trim(); + if (trimmedName && trimmedName !== name) { + onSave(trimmedName + extension); + } + setIsEditing(false); + }; + + const handleCancel = () => { + setEditedName(name); + setIsEditing(false); + }; + + const handleKeyDown = (e: React.KeyboardEvent) => { + if (e.key === "Enter") { + handleSave(); + } else if (e.key === "Escape") { + handleCancel(); + } + }; + + if (isEditing) { + return ( +
+
+ setEditedName(e.target.value)} + onKeyDown={handleKeyDown} + autoFocus + className="h-8 flex-1 rounded-r-none text-sm" + /> + {extension && ( + + {extension} + + )} +
+ + +
+ ); + } + + return ( +
+ + {filename} + + {!disabled && ( + + )} +
+ ); +} diff --git a/packages/ui/spa/components/FileGallery/index.ts b/packages/ui/spa/components/FileGallery/index.ts index cd73f141e..014b0d061 100644 --- a/packages/ui/spa/components/FileGallery/index.ts +++ b/packages/ui/spa/components/FileGallery/index.ts @@ -1,6 +1,14 @@ export { FileGallery } from "./FileGallery"; export { FileGalleryItem } from "./FileGalleryItem"; +export { FileGalleryListView } from "./FileGalleryListView"; +export { FilenameInput } from "./FilenameInput"; export { FilePreview } from "./FilePreview"; -export { FilePreviewModal } from "./FilePreviewModal"; -export { FileProperties } from "./FileProperties"; -export type { FileGalleryProps, FileMetadata, GalleryFile } from "./types"; +export { FilePropertiesModal } from "./FilePropertiesModal"; +export type { + FileGalleryProps, + FileMetadata, + GalleryFile, + SortDirection, + SortField, + ViewMode, +} from "./types"; diff --git a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx index 9edfc81d7..ee1de4567 100644 --- a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx +++ b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx @@ -24,7 +24,9 @@ const imageFiles: GalleryFile[] = [ width: 800, height: 600, mimeType: "image/jpeg", + alt: "A beautiful landscape", }, + createdAt: new Date("2025-12-15T10:30:00"), }, { url: "/sample-image-2.jpg", @@ -35,6 +37,7 @@ const imageFiles: GalleryFile[] = [ height: 800, mimeType: "image/jpeg", }, + createdAt: new Date("2025-12-20T14:45:00"), }, { url: "/sample-image-3.jpg", @@ -44,6 +47,7 @@ const imageFiles: GalleryFile[] = [ width: 1200, height: 800, mimeType: "image/jpeg", + alt: "Wide panoramic shot", }, }, ]; @@ -59,6 +63,7 @@ const mixedFiles: GalleryFile[] = [ height: 176, mimeType: "video/mp4", }, + createdAt: new Date("2025-11-10T09:00:00"), }, { url: "#", @@ -69,6 +74,7 @@ const mixedFiles: GalleryFile[] = [ height: 0, mimeType: "audio/mpeg", }, + createdAt: new Date("2026-01-05T16:20:00"), }, { url: "#", @@ -79,6 +85,7 @@ const mixedFiles: GalleryFile[] = [ height: 0, mimeType: "application/json", }, + createdAt: new Date("2025-10-01T12:00:00"), }, { url: "#", @@ -89,6 +96,7 @@ const mixedFiles: GalleryFile[] = [ height: 0, mimeType: "text/plain", }, + createdAt: new Date("2026-02-01T08:30:00"), }, { url: "#", @@ -99,6 +107,7 @@ const mixedFiles: GalleryFile[] = [ height: 0, mimeType: "application/zip", }, + createdAt: new Date("2025-12-25T00:00:00"), }, ]; @@ -151,3 +160,168 @@ export const ManyFiles: Story = { /> ), }; + +export const GridView: Story = { + render: () => ( + ({ + ...f, + filename: `copy-${i + 1}-${f.filename}`, + })), + ]} + defaultViewMode="grid" + /> + ), +}; + +export const WithoutSearch: Story = { + render: () => , +}; + +export const ImageModeWithAltText: Story = { + render: function Render() { + const [files, setFiles] = useState(imageFiles); + + const handleRename = (index: number, newFilename: string) => { + setFiles((prev) => + prev.map((file, i) => + i === index ? { ...file, filename: newFilename } : file, + ), + ); + }; + + const handleAltTextChange = (index: number, newAltText: string) => { + setFiles((prev) => + prev.map((file, i) => + i === index + ? { ...file, metadata: { ...file.metadata, alt: newAltText } } + : file, + ), + ); + }; + + return ( + + ); + }, +}; + +export const ListView: Story = { + render: () => ( + + ), +}; + +export const WithValidationErrors: Story = { + render: () => ( + + ), +}; + +export const Loading: Story = { + render: () => , +}; + +export const Disabled: Story = { + render: function Render() { + const handleRename = (index: number, newFilename: string) => { + console.log(`Rename file ${index} to: ${newFilename}`); + }; + + const handleAltTextChange = (index: number, newAltText: string) => { + console.log(`Alt text for ${index}: ${newAltText}`); + }; + + return ( + + ); + }, +}; + +// Generate many files for virtualization testing +function generateManyFiles(count: number): GalleryFile[] { + const baseFiles = [ + { + url: "/sample-image-1.jpg", + filename: "landscape", + folder: "/images/photos", + metadata: { width: 800, height: 600, mimeType: "image/jpeg" }, + }, + { + url: "/sample-image-2.jpg", + filename: "portrait", + folder: "/images/photos", + metadata: { width: 600, height: 800, mimeType: "image/jpeg" }, + }, + { + url: "/sample-image-3.jpg", + filename: "wide-shot", + folder: "/images/banners", + metadata: { width: 1200, height: 800, mimeType: "image/jpeg" }, + }, + { + url: "/sample-video.mp4", + filename: "video", + folder: "/media/videos", + metadata: { width: 1920, height: 1080, mimeType: "video/mp4" }, + }, + { + url: "/document.pdf", + filename: "document", + folder: "/docs", + metadata: { width: 0, height: 0, mimeType: "application/pdf" }, + }, + ]; + + return Array.from({ length: count }, (_, i) => { + const base = baseFiles[i % baseFiles.length]; + return { + ...base, + filename: `${base.filename}-${i + 1}.${base.metadata.mimeType.split("/")[1]}`, + createdAt: new Date(Date.now() - i * 1000 * 60 * 60 * 24), + }; + }); +} + +export const VirtualizedList: Story = { + render: () => ( + + ), +}; + +export const VirtualizedMasonry: Story = { + render: () => ( + + ), +}; diff --git a/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx new file mode 100644 index 000000000..48d2b47e7 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx @@ -0,0 +1,163 @@ +import type { Meta, StoryObj } from "@storybook/react"; +import { FileProperties } from "../FileProperties"; +import type { GalleryFile } from "../types"; + +const meta: Meta = { + title: "FileGallery/FileProperties", + component: FileProperties, + parameters: { + layout: "padded", + }, + decorators: [ + (Story) => ( +
+ +
+ ), + ], +}; + +export default meta; +type Story = StoryObj; + +const sampleImageFile: GalleryFile = { + url: "/sample-landscape.jpg", + filename: "sample-landscape.jpg", + folder: "/public/val/images", + metadata: { + width: 1920, + height: 1080, + mimeType: "image/jpeg", + alt: "A beautiful mountain landscape", + }, + createdAt: new Date("2024-01-15T10:30:00"), +}; + +const sampleVideoFile: GalleryFile = { + url: "/sample-video.mp4", + filename: "promotional-video.mp4", + folder: "/public/val/videos", + metadata: { + width: 1920, + height: 1080, + mimeType: "video/mp4", + }, + createdAt: new Date("2024-02-20T14:45:00"), +}; + +const sampleDocumentFile: GalleryFile = { + url: "/document.pdf", + filename: "annual-report-2024.pdf", + folder: "/public/val/documents", + metadata: { + width: 0, + height: 0, + mimeType: "application/pdf", + }, +}; + +const fileWithoutAlt: GalleryFile = { + url: "/no-alt-image.png", + filename: "no-alt-image.png", + folder: "/public/val/images", + metadata: { + width: 800, + height: 600, + mimeType: "image/png", + }, + createdAt: new Date("2024-03-10T09:00:00"), +}; + +export const ImageFile: Story = { + args: { + file: sampleImageFile, + fileIndex: 0, + imageMode: true, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + onAltTextChange: (index, newAltText) => + console.log(`Alt text for ${index}: ${newAltText}`), + }, +}; + +export const ImageFileReadOnly: Story = { + args: { + file: sampleImageFile, + fileIndex: 0, + imageMode: true, + }, +}; + +export const ImageWithoutAltText: Story = { + args: { + file: fileWithoutAlt, + fileIndex: 0, + imageMode: true, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + onAltTextChange: (index, newAltText) => + console.log(`Alt text for ${index}: ${newAltText}`), + }, +}; + +export const VideoFile: Story = { + args: { + file: sampleVideoFile, + fileIndex: 0, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + }, +}; + +export const DocumentFile: Story = { + args: { + file: sampleDocumentFile, + fileIndex: 0, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + }, +}; + +export const WithoutCreatedDate: Story = { + args: { + file: sampleDocumentFile, + fileIndex: 0, + }, +}; + +export const ImageModeOff: Story = { + args: { + file: sampleImageFile, + fileIndex: 0, + imageMode: false, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + onAltTextChange: (index, newAltText) => + console.log(`Alt text for ${index}: ${newAltText}`), + }, +}; + +export const LongFilename: Story = { + args: { + file: { + ...sampleImageFile, + filename: + "this-is-a-very-long-filename-that-should-be-truncated-properly-in-the-ui.jpg", + }, + fileIndex: 0, + imageMode: true, + onFileRename: (index, newFilename) => + console.log(`Rename file ${index} to: ${newFilename}`), + }, +}; + +export const LongFolderPath: Story = { + args: { + file: { + ...sampleImageFile, + folder: "/public/val/images/deeply/nested/folder/structure/here", + }, + fileIndex: 0, + imageMode: true, + }, +}; diff --git a/packages/ui/spa/components/FileGallery/stories/FilenameInput.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FilenameInput.stories.tsx new file mode 100644 index 000000000..fbefa3fa8 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/stories/FilenameInput.stories.tsx @@ -0,0 +1,90 @@ +import type { Meta, StoryObj } from "@storybook/react"; +import { useState } from "react"; +import { FilenameInput } from "../FilenameInput"; + +const meta: Meta = { + title: "FileGallery/FilenameInput", + component: FilenameInput, + parameters: { + layout: "padded", + }, + decorators: [ + (Story) => ( +
+ +
+ ), + ], +}; + +export default meta; +type Story = StoryObj; + +export const Default: Story = { + args: { + filename: "landscape.jpg", + onSave: (newFilename) => console.log("Save:", newFilename), + }, +}; + +export const WithLongFilename: Story = { + args: { + filename: "this-is-a-very-long-filename-that-should-truncate.jpg", + onSave: (newFilename) => console.log("Save:", newFilename), + }, +}; + +export const NoExtension: Story = { + args: { + filename: "README", + onSave: (newFilename) => console.log("Save:", newFilename), + }, +}; + +export const MultipleExtensions: Story = { + args: { + filename: "archive.tar.gz", + onSave: (newFilename) => console.log("Save:", newFilename), + }, +}; + +export const HiddenFile: Story = { + args: { + filename: ".gitignore", + onSave: (newFilename) => console.log("Save:", newFilename), + }, +}; + +export const Disabled: Story = { + args: { + filename: "readonly-file.pdf", + onSave: (newFilename) => console.log("Save:", newFilename), + disabled: true, + }, +}; + +export const Interactive: Story = { + render: function Render() { + const [filename, setFilename] = useState("my-photo.jpg"); + + return ( +
+ +

+ Current filename: {filename} +

+
+ ); + }, +}; + +export const DifferentExtensions: Story = { + render: () => ( +
+ console.log(f)} /> + console.log(f)} /> + console.log(f)} /> + console.log(f)} /> +
+ ), +}; diff --git a/packages/ui/spa/components/FileGallery/types.ts b/packages/ui/spa/components/FileGallery/types.ts index 37bb52215..c3bbbf2ad 100644 --- a/packages/ui/spa/components/FileGallery/types.ts +++ b/packages/ui/spa/components/FileGallery/types.ts @@ -2,6 +2,7 @@ export interface FileMetadata { width: number; height: number; mimeType: string; + alt?: string; } export interface GalleryFile { @@ -9,10 +10,23 @@ export interface GalleryFile { filename: string; folder: string; metadata: FileMetadata; + createdAt?: Date; + validationErrors?: string[]; } +export type ViewMode = "masonry" | "grid" | "list"; + +export type SortField = "name" | "type"; +export type SortDirection = "asc" | "desc"; + export interface FileGalleryProps { files: GalleryFile[]; onFileRename?: (index: number, newFilename: string) => void; + onAltTextChange?: (index: number, newAltText: string) => void; className?: string; + defaultViewMode?: ViewMode; + showSearch?: boolean; + imageMode?: boolean; + loading?: boolean; + disabled?: boolean; } diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index e46426e98..d076a2f33 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -578,6 +578,10 @@ importers: version: 5.9.3 packages/ui: + dependencies: + '@tanstack/react-virtual': + specifier: ^3.13.18 + version: 3.13.18(react-dom@18.2.0(react@18.2.0))(react@18.2.0) devDependencies: '@codemirror/lang-angular': specifier: ^0.1.4 @@ -4550,6 +4554,15 @@ packages: '@swc/helpers@0.5.5': resolution: {integrity: sha512-KGYxvIOXcceOAbEk4bi/dVLEK9z8sZ0uBB3Il5b1rhfClSpcX0yfRO0KmTkqR2cnQDymwLB+25ZyMzICg/cm/A==} + '@tanstack/react-virtual@3.13.18': + resolution: {integrity: sha512-dZkhyfahpvlaV0rIKnvQiVoWPyURppl6w4m9IwMDpuIjcJ1sD9YGWrt0wISvgU7ewACXx2Ct46WPgI6qAD4v6A==} + peerDependencies: + react: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + react-dom: ^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0 + + '@tanstack/virtual-core@3.13.18': + resolution: {integrity: sha512-Mx86Hqu1k39icq2Zusq+Ey2J6dDWTjDvEv43PJtRCoEYTLyfaPnxIQ6iy7YAOK0NV/qOEmZQ/uCufrppZxTgcg==} + '@testing-library/dom@8.20.1': resolution: {integrity: sha512-/DiOQ5xBxgdYRC8LNk7U+RWat0S3qRLeIw3ZIkMQ9kkVlRmwD/Eg8k8CqIpD6GW7u20JIUOfMKbxtiLutpjQ4g==} engines: {node: '>=12'} @@ -15274,6 +15287,14 @@ snapshots: '@swc/counter': 0.1.3 tslib: 2.8.1 + '@tanstack/react-virtual@3.13.18(react-dom@18.2.0(react@18.2.0))(react@18.2.0)': + dependencies: + '@tanstack/virtual-core': 3.13.18 + react: 18.2.0 + react-dom: 18.2.0(react@18.2.0) + + '@tanstack/virtual-core@3.13.18': {} + '@testing-library/dom@8.20.1': dependencies: '@babel/code-frame': 7.28.6 @@ -17383,7 +17404,7 @@ snapshots: eslint: 8.32.0 eslint-import-resolver-node: 0.3.9 eslint-import-resolver-typescript: 3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.1(eslint@9.39.2(jiti@1.21.7))(typescript@5.9.3))(eslint@8.32.0))(eslint@8.32.0) - eslint-plugin-import: 2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.1(eslint@9.39.2(jiti@1.21.7))(typescript@5.9.3))(eslint@8.32.0))(eslint@8.32.0))(eslint@8.32.0) + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.32.0) eslint-plugin-jsx-a11y: 6.10.2(eslint@8.32.0) eslint-plugin-react: 7.37.5(eslint@8.32.0) eslint-plugin-react-hooks: 4.6.2(eslint@8.32.0) @@ -17429,7 +17450,7 @@ snapshots: tinyglobby: 0.2.15 unrs-resolver: 1.11.1 optionalDependencies: - eslint-plugin-import: 2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.1(eslint@9.39.2(jiti@1.21.7))(typescript@5.9.3))(eslint@8.32.0))(eslint@8.32.0))(eslint@8.32.0) + eslint-plugin-import: 2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.32.0) transitivePeerDependencies: - supports-color @@ -17484,7 +17505,7 @@ snapshots: - eslint-import-resolver-webpack - supports-color - eslint-plugin-import@2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1(eslint-plugin-import@2.32.0(@typescript-eslint/parser@8.53.1(eslint@9.39.2(jiti@1.21.7))(typescript@5.9.3))(eslint@8.32.0))(eslint@8.32.0))(eslint@8.32.0): + eslint-plugin-import@2.32.0(@typescript-eslint/parser@5.62.0(eslint@8.32.0)(typescript@5.1.3))(eslint-import-resolver-typescript@3.10.1)(eslint@8.32.0): dependencies: '@rtsao/scc': 1.1.0 array-includes: 3.1.9 From bf666939fdc5e5fb54e75013beca168ff34d4ccb Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Sat, 7 Feb 2026 12:19:06 +0100 Subject: [PATCH 04/32] Enrich c.image and c.file with metadata from s.images and s.files --- .../enrichFileImageSourceWithRemote.test.ts | 468 ++++++++++++++++++ packages/core/src/module.ts | 84 +++- packages/core/src/schema/file.ts | 62 ++- packages/core/src/schema/image.ts | 67 ++- 4 files changed, 657 insertions(+), 24 deletions(-) create mode 100644 packages/core/src/enrichFileImageSourceWithRemote.test.ts diff --git a/packages/core/src/enrichFileImageSourceWithRemote.test.ts b/packages/core/src/enrichFileImageSourceWithRemote.test.ts new file mode 100644 index 000000000..1377af4e8 --- /dev/null +++ b/packages/core/src/enrichFileImageSourceWithRemote.test.ts @@ -0,0 +1,468 @@ +import { initVal } from "./initVal"; +import { enrichFileImageSourceWithRemote } from "./module"; +import { FilesEntryMetadata } from "./schema/files"; +import { ImagesEntryMetadata } from "./schema/images"; +import { Internal } from "."; + +describe("enrichFileImageSourceWithRemote", () => { + test("should enrich image source with metadata from images module", () => { + const { c, s } = initVal(); + + // Define an images module (like media.val.ts) + const imagesModule = c.define( + "/content/images.val.ts", + s.images({ + accept: "image/webp", + directory: "/public/val/images", + }), + { + "/public/val/images/logo.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "An example image", + }, + } as Record, + ); + + const testSchema = s.object({ + test: s.image(imagesModule), + }); + + const testModule = c.define("/content/test.val.ts", testSchema, { + test: c.image("/public/val/images/logo.png"), + }); + const source = Internal.getSource(testModule); + const enrichedSource = enrichFileImageSourceWithRemote(source, testSchema); + expect(enrichedSource).toEqual({ + test: c.image("/public/val/images/logo.png", { + width: 800, + height: 600, + mimeType: "image/png", + alt: "An example image", + }), + }); + }); + + test("should enrich deeply nested schema with multiple images, files, records, arrays, unions, and richtext", () => { + const { c, s } = initVal(); + + // Define 3 different images modules + const avatarsModule = c.define( + "/content/avatars.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/avatars", + }), + { + "/public/val/avatars/john.png": { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }, + "/public/val/avatars/jane.png": { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }, + } as Record, + ); + + const productsModule = c.define( + "/content/products.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/products", + }), + { + "/public/val/products/widget.jpg": { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + "/public/val/products/gadget.jpg": { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + "/public/val/products/inline-product.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, + } as Record, + ); + + const bannersModule = c.define( + "/content/banners.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/banners", + }), + { + "/public/val/banners/hero.webp": { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }, + "/public/val/banners/promo.webp": { + width: 1200, + height: 600, + mimeType: "image/webp", + alt: "Promo banner", + }, + } as Record, + ); + + // Define 1 files module + const documentsModule = c.define( + "/content/documents.val.ts", + s.files({ + accept: "application/pdf", + directory: "/public/val/documents", + }), + { + "/public/val/documents/manual.pdf": { + mimeType: "application/pdf", + }, + "/public/val/documents/brochure.pdf": { + mimeType: "application/pdf", + }, + } as Record, + ); + + // Create deeply nested schema with all combinations + const deepSchema = s.object({ + // Simple nested object with image + header: s.object({ + banner: s.image(bannersModule), + }), + + // Record -> Object -> Image + users: s.record( + s.object({ + name: s.string(), + avatar: s.image(avatarsModule), + }), + ), + + // Array -> Object -> Object -> Array -> Image (deep nesting) + products: s.array( + s.object({ + name: s.string(), + details: s.object({ + description: s.string(), + gallery: s.array(s.image(productsModule)), + }), + }), + ), + + // Array -> Union with different types at each variant + contentBlocks: s.array( + s.union( + "type", + s.object({ + type: s.literal("hero"), + backgroundImage: s.image(bannersModule), + }), + s.object({ + type: s.literal("product"), + productImage: s.image(productsModule), + }), + s.object({ + type: s.literal("document"), + file: s.file(documentsModule), + }), + s.object({ + type: s.literal("article"), + body: s.richtext({ + inline: { + img: s.image(productsModule), + }, + }), + }), + ), + ), + + // Union at object level + sidebar: s.union( + "variant", + s.object({ + variant: s.literal("promo"), + promoImage: s.image(bannersModule), + }), + s.object({ + variant: s.literal("download"), + downloadFile: s.file(documentsModule), + }), + ), + + // Deep 3-level object nesting with richtext at bottom + nested: s.object({ + level1: s.object({ + level2: s.object({ + level3: s.object({ + deepImage: s.image(avatarsModule), + richContent: s.richtext({ + inline: { + img: s.image(avatarsModule), + }, + }), + }), + }), + }), + }), + }); + + // Create test data + const testModule = c.define("/content/deep-test.val.ts", deepSchema, { + header: { + banner: c.image("/public/val/banners/hero.webp"), + }, + + users: { + john: { + name: "John Doe", + avatar: c.image("/public/val/avatars/john.png"), + }, + jane: { + name: "Jane Smith", + avatar: c.image("/public/val/avatars/jane.png"), + }, + }, + + products: [ + { + name: "Widget", + details: { + description: "A useful widget", + gallery: [ + c.image("/public/val/products/widget.jpg"), + c.image("/public/val/products/gadget.jpg"), + ], + }, + }, + ], + + contentBlocks: [ + { + type: "hero" as const, + backgroundImage: c.image("/public/val/banners/hero.webp"), + }, + { + type: "product" as const, + productImage: c.image("/public/val/products/widget.jpg"), + }, + { + type: "document" as const, + file: c.file("/public/val/documents/manual.pdf"), + }, + { + type: "article" as const, + body: [ + { + tag: "p", + children: [ + "Check out this product: ", + { + tag: "img", + src: c.image("/public/val/products/inline-product.png"), + }, + ], + }, + ], + }, + ], + + sidebar: { + variant: "promo" as const, + promoImage: c.image("/public/val/banners/promo.webp"), + }, + + nested: { + level1: { + level2: { + level3: { + deepImage: c.image("/public/val/avatars/john.png"), + richContent: [ + { + tag: "p", + children: [ + "Deep content with image: ", + { + tag: "img", + src: c.image("/public/val/avatars/jane.png"), + }, + ], + }, + ], + }, + }, + }, + }, + }); + + const source = Internal.getSource(testModule); + const enrichedSource = enrichFileImageSourceWithRemote( + source, + deepSchema, + ) as typeof source; + + // Verify header banner + expect(enrichedSource.header.banner).toEqual( + c.image("/public/val/banners/hero.webp", { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }), + ); + + // Verify record -> object -> image + expect(enrichedSource.users.john.avatar).toEqual( + c.image("/public/val/avatars/john.png", { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }), + ); + expect(enrichedSource.users.jane.avatar).toEqual( + c.image("/public/val/avatars/jane.png", { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }), + ); + + // Verify array -> object -> object -> array -> image + expect(enrichedSource.products[0].details.gallery[0]).toEqual( + c.image("/public/val/products/widget.jpg", { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }), + ); + expect(enrichedSource.products[0].details.gallery[1]).toEqual( + c.image("/public/val/products/gadget.jpg", { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }), + ); + + // Verify array -> union variants + const heroBlock = enrichedSource.contentBlocks[0] as { + type: "hero"; + backgroundImage: ReturnType; + }; + expect(heroBlock.backgroundImage).toEqual( + c.image("/public/val/banners/hero.webp", { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }), + ); + + const productBlock = enrichedSource.contentBlocks[1] as { + type: "product"; + productImage: ReturnType; + }; + expect(productBlock.productImage).toEqual( + c.image("/public/val/products/widget.jpg", { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }), + ); + + const documentBlock = enrichedSource.contentBlocks[2] as { + type: "document"; + file: ReturnType; + }; + expect(documentBlock.file).toEqual( + c.file("/public/val/documents/manual.pdf", { + mimeType: "application/pdf", + }), + ); + + // Verify richtext inline image in union + const articleBlock = enrichedSource.contentBlocks[3] as { + type: "article"; + body: Array<{ + tag: string; + children: Array< + string | { tag: string; src: ReturnType } + >; + }>; + }; + const inlineImg = articleBlock.body[0].children[1] as { + tag: string; + src: ReturnType; + }; + expect(inlineImg.src).toEqual( + c.image("/public/val/products/inline-product.png", { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }), + ); + + // Verify sidebar union + const sidebarPromo = enrichedSource.sidebar as { + variant: "promo"; + promoImage: ReturnType; + }; + expect(sidebarPromo.promoImage).toEqual( + c.image("/public/val/banners/promo.webp", { + width: 1200, + height: 600, + mimeType: "image/webp", + alt: "Promo banner", + }), + ); + + // Verify deep nested object with image + expect(enrichedSource.nested.level1.level2.level3.deepImage).toEqual( + c.image("/public/val/avatars/john.png", { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }), + ); + + // Verify deep nested richtext inline image + const deepRichContent = enrichedSource.nested.level1.level2.level3 + .richContent as Array<{ + tag: string; + children: Array< + string | { tag: string; src: ReturnType } + >; + }>; + const deepInlineImg = deepRichContent[0].children[1] as { + tag: string; + src: ReturnType; + }; + expect(deepInlineImg.src).toEqual( + c.image("/public/val/avatars/jane.png", { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }), + ); + }); +}); diff --git a/packages/core/src/module.ts b/packages/core/src/module.ts index 5e6840ad4..734bd1933 100644 --- a/packages/core/src/module.ts +++ b/packages/core/src/module.ts @@ -9,7 +9,7 @@ import { Path, } from "./selector"; import { Source } from "./source"; -import { ModuleFilePath, ModulePath, SourcePath } from "./val"; +import { getValPath, ModuleFilePath, ModulePath, SourcePath } from "./val"; import { ArraySchema, SerializedArraySchema } from "./schema/array"; import { UnionSchema, SerializedUnionSchema } from "./schema/union"; import { Json } from "./Json"; @@ -19,13 +19,13 @@ import { ImageSchema, SerializedImageSchema, } from "./schema/image"; -import { FileSource } from "./source/file"; +import { FILE_REF_PROP, FileSource } from "./source/file"; import { AllRichTextOptions, RichTextSource } from "./source/richtext"; import { RecordSchema, SerializedRecordSchema } from "./schema/record"; import { RawString } from "./schema/string"; import { ImageSelector } from "./selector/image"; import { ImageSource } from "./source/image"; -import { ModuleFilePathSep } from "."; +import { FileMetadata, FileSchema, ModuleFilePathSep } from "."; const brand = Symbol("ValModule"); export type ValModule = SelectorOf & @@ -55,9 +55,7 @@ export type ReplaceRawStringWithString = export function define>( id: string, // TODO: `/${string}` - schema: T, - source: ReplaceRawStringWithString>, ): ValModule> { return { @@ -67,6 +65,82 @@ export function define>( } as unknown as ValModule>; } +export function enrichFileImageSourceWithRemote( + source: SelectorSource, + schema: Schema, +): SelectorSource { + const addedModules = new Set(); + let filesLookup: Record = {}; + function traverseSchema(schema: Schema) { + if (schema instanceof ImageSchema || schema instanceof FileSchema) { + const moduleMetadata = + schema instanceof ImageSchema + ? schema["moduleMetadata"] + : schema["moduleMetadata"]; + for (const [modulePath, valModule] of Object.entries( + moduleMetadata || {}, + )) { + if (addedModules.has(modulePath)) { + continue; + } + addedModules.add(modulePath); + filesLookup = { + ...filesLookup, + ...valModule, + }; + } + } else if (schema instanceof ObjectSchema) { + for (const value of Object.values(schema["items"])) { + if (value instanceof Schema) { + traverseSchema(value); + } + } + } else if (schema instanceof ArraySchema) { + traverseSchema(schema["item"]); + } else if (schema instanceof RecordSchema) { + traverseSchema(schema["item"]); + } else if (schema instanceof UnionSchema) { + for (const value of schema["items"]) { + if (value instanceof ObjectSchema) { + traverseSchema(value); + } + } + } else if (schema instanceof RichTextSchema) { + if (schema["options"]?.inline?.img instanceof ImageSchema) { + traverseSchema(schema["options"].inline.img); + } + } + } + function injectMetadataIntoSource(source: SelectorSource): SelectorSource { + if (!source) { + return source; + } + if ( + typeof source === "object" && + FILE_REF_PROP in source && + typeof source[FILE_REF_PROP] === "string" + ) { + const fileRef = source[FILE_REF_PROP]; + const metadata = filesLookup[fileRef]; + // eslint-disable-next-line @typescript-eslint/no-explicit-any + (source as any).metadata = metadata; + } else if (typeof source === "object") { + if (Array.isArray(source)) { + for (const item of source) { + injectMetadataIntoSource(item); + } + } else { + for (const value of Object.values(source)) { + injectMetadataIntoSource(value); + } + } + } + } + traverseSchema(schema); + injectMetadataIntoSource(source); + return source; +} + export function getSource(valModule: ValModule): Source { const sourceOrExpr = valModule[GetSource]; const source = sourceOrExpr; diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index 0b0514aca..1fec651cf 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -8,13 +8,15 @@ import { SerializedSchema, } from "."; import { VAL_EXTENSION } from "../source"; -import { SourcePath } from "../val"; +import { getValPath, ModulePath, SourcePath } from "../val"; import { ValidationError, ValidationErrors, } from "./validation/ValidationError"; -import { Internal, RemoteSource } from ".."; +import { Internal, RemoteSource, ValModule } from ".."; import { ReifiedRender } from "../render"; +import { FilesEntryMetadata } from "./files"; +import { getSource } from "../module"; export type FileOptions = { accept?: string; @@ -42,19 +44,32 @@ export class FileSchema< private readonly opt: boolean = false, protected readonly isRemote: boolean = false, private readonly customValidateFunctions: CustomValidateFunction[] = [], + private readonly moduleMetadata: Record< + ModulePath, + Record + > = {}, ) { super(); } remote(): FileSchema> { - return new FileSchema(this.options, this.opt, true); + return new FileSchema( + this.options, + this.opt, + true, + this.customValidateFunctions, + this.moduleMetadata, + ) as FileSchema>; } validate(validationFunction: CustomValidateFunction): FileSchema { - return new FileSchema(this.options, this.opt, this.isRemote, [ - ...this.customValidateFunctions, - validationFunction, - ]); + return new FileSchema( + this.options, + this.opt, + this.isRemote, + [...this.customValidateFunctions, validationFunction], + this.moduleMetadata, + ); } protected executeValidate(path: SourcePath, src: Src): ValidationErrors { @@ -298,7 +313,7 @@ export class FileSchema< } nullable(): FileSchema { - return new FileSchema(this.options, true); + return new FileSchema(this.options, true, this.isRemote); } protected executeSerialize(): SerializedSchema { @@ -319,9 +334,36 @@ export class FileSchema< } export const file = ( - options?: FileOptions, + options?: FileOptions | ValModule>, + ...args: ValModule>[] ): FileSchema> => { - return new FileSchema(options); + const isModule = !!Internal.getValPath( + options as ValModule>, + ); + if (isModule) { + const allModules: Record> = {}; + for (const valModule of [ + options as ValModule>, + ...args, + ]) { + const modulePath = getValPath(valModule) as ModulePath | undefined; + if (modulePath === undefined) { + throw new Error( + `Invalid argument passed to s.file(). Expected a ValModule constructed through c.define, but got an object without a valid module path.`, + ); + } + allModules[modulePath] = getSource(valModule) as Record< + string, + FilesEntryMetadata + >; + } + return new FileSchema({}, false, false, [], allModules); + } else if (args.length > 0) { + throw new Error( + `When passing a options to s.file(), you cannot pass additional arguments.`, + ); + } + return new FileSchema(options as FileOptions); }; export function convertFileSource< diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index b15da5d4d..780829ab0 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -8,14 +8,16 @@ import { import { VAL_EXTENSION } from "../source"; import { FileSource, FILE_REF_PROP } from "../source/file"; import { ImageSource } from "../source/image"; -import { SourcePath } from "../val"; +import { getValPath, ModulePath, SourcePath } from "../val"; import { ValidationError, ValidationErrors, } from "./validation/ValidationError"; -import { FileMetadata, FileSchema, Internal } from ".."; +import { FileMetadata, Internal, ValModule } from ".."; import { RemoteSource } from "../source/remote"; import { ReifiedRender } from "../render"; +import { ImagesEntryMetadata } from "./images"; +import { getSource } from "../module"; export type ImageOptions = { ext?: ["jpg"] | ["webp"]; @@ -30,6 +32,7 @@ export type SerializedImageSchema = { opt: boolean; remote?: boolean; customValidate?: boolean; + moduleMetadata?: Record>; }; export type ImageMetadata = FileMetadata & { @@ -52,19 +55,32 @@ export class ImageSchema< private readonly opt: boolean = false, protected readonly isRemote: boolean = false, private readonly customValidateFunctions: CustomValidateFunction[] = [], + private readonly moduleMetadata: Record< + ModulePath, + Record + > = {}, ) { super(); } remote(): ImageSchema> { - return new ImageSchema(this.options, this.opt, true); + return new ImageSchema( + this.options, + this.opt, + true, + this.customValidateFunctions, + this.moduleMetadata, + ) as ImageSchema>; } validate(validationFunction: CustomValidateFunction): ImageSchema { - return new ImageSchema(this.options, this.opt, this.isRemote, [ - ...this.customValidateFunctions, - validationFunction, - ]); + return new ImageSchema( + this.options, + this.opt, + this.isRemote, + [...this.customValidateFunctions, validationFunction], + this.moduleMetadata, + ); } protected executeValidate(path: SourcePath, src: Src): ValidationErrors { @@ -342,6 +358,10 @@ export class ImageSchema< customValidate: this.customValidateFunctions && this.customValidateFunctions?.length > 0, + moduleMetadata: + this.moduleMetadata && Object.keys(this.moduleMetadata).length > 0 + ? this.moduleMetadata + : undefined, }; } @@ -350,6 +370,35 @@ export class ImageSchema< } } -export const image = (options?: ImageOptions): ImageSchema => { - return new ImageSchema(options); +export const image = ( + options?: ImageOptions | ValModule>, + ...args: ValModule>[] +): ImageSchema => { + const isModule = !!Internal.getValPath( + options as ValModule>, + ); + if (isModule) { + const allModules: Record> = {}; + for (const valModule of [ + options as ValModule>, + ...args, + ]) { + const modulePath = getValPath(valModule) as ModulePath | undefined; + if (modulePath === undefined) { + throw new Error( + `Invalid argument passed to s.image(). Expected a ValModule constructed through c.define, but got an object without a valid module path.`, + ); + } + allModules[modulePath] = getSource(valModule) as Record< + string, + ImagesEntryMetadata + >; + } + return new ImageSchema({}, false, false, [], allModules); + } else if (args.length > 0) { + throw new Error( + `When passing a options to s.image(), you cannot pass additional arguments.`, + ); + } + return new ImageSchema(options as ImageOptions); }; From b5f8f56be50a182fbbac13d14211d73c95cf7a6d Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Sat, 7 Feb 2026 12:19:24 +0100 Subject: [PATCH 05/32] Support for enriched metadata for remote as well --- examples/next/content/authors.val.ts | 8 + examples/next/content/media.val.ts | 4 +- .../val/{logo_7adc7.png => images/logo.png} | Bin ...hFileImageRemoteSourceWithMetadata.test.ts | 469 ++++++++++++++++++ .../enrichFileImageSourceWithRemote.test.ts | 151 +++--- packages/core/src/module.ts | 4 +- 6 files changed, 573 insertions(+), 63 deletions(-) rename examples/next/public/val/{logo_7adc7.png => images/logo.png} (100%) create mode 100644 packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts diff --git a/examples/next/content/authors.val.ts b/examples/next/content/authors.val.ts index 84ff04f92..63d9d7bd9 100644 --- a/examples/next/content/authors.val.ts +++ b/examples/next/content/authors.val.ts @@ -1,10 +1,12 @@ import { s, c, type t } from "../val.config"; +import mediaVal from "./media.val"; export const schema = s .record( s.object({ name: s.string().minLength(2), birthdate: s.date().from("1900-01-01").to("2024-01-01").nullable(), + image: s.image(mediaVal).nullable(), }), ) .render({ @@ -20,25 +22,31 @@ export default c.define("/content/authors.val.ts", schema, { teddy: { name: "Theodor René Carlsen", birthdate: null, + image: c.image("/public/val/images/logo.png"), }, freekh: { name: "Fredrik Ekholdt", birthdate: "1981-12-30", + image: null, }, erlamd: { name: "Erlend Åmdal", birthdate: null, + image: null, }, thoram: { name: "Thomas Ramirez", birthdate: null, + image: null, }, isabjo: { name: "Isak Bjørnstad", birthdate: null, + image: null, }, kimmid: { name: "Kim Midtlid", birthdate: null, + image: null, }, }); diff --git a/examples/next/content/media.val.ts b/examples/next/content/media.val.ts index 4b507e311..d7792cb1f 100644 --- a/examples/next/content/media.val.ts +++ b/examples/next/content/media.val.ts @@ -8,10 +8,10 @@ export default c.define( alt: s.string().minLength(4), }), { - "/public/val/images/foo.webp": { + "/public/val/images/logo.png": { width: 800, height: 600, - mimeType: "image/webp", + mimeType: "image/png", alt: "An example image", }, }, diff --git a/examples/next/public/val/logo_7adc7.png b/examples/next/public/val/images/logo.png similarity index 100% rename from examples/next/public/val/logo_7adc7.png rename to examples/next/public/val/images/logo.png diff --git a/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts b/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts new file mode 100644 index 000000000..ecd7b4d8d --- /dev/null +++ b/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts @@ -0,0 +1,469 @@ +import { initVal } from "./initVal"; +import { enrichFileImageRemoteSourceWithMetadata } from "./module"; +import { FilesEntryMetadata } from "./schema/files"; +import { ImagesEntryMetadata } from "./schema/images"; +import { Internal } from "."; + +describe("enrichFileImageRemoteSourceWithMetadata", () => { + test("should enrich image source with metadata from images module", () => { + const { c, s } = initVal(); + + // Define an images module (like media.val.ts) + const imagesModule = c.define( + "/content/images.val.ts", + s.images({ + accept: "image/webp", + directory: "/public/val/images", + }), + { + "/public/val/images/logo.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "An example image", + }, + } as Record, + ); + + const testSchema = s.object({ + test: s.image(imagesModule), + }); + + const testModule = c.define("/content/test.val.ts", testSchema, { + test: c.image("/public/val/images/logo.png"), + }); + const source = Internal.getSource(testModule); + const enrichedSource = enrichFileImageRemoteSourceWithMetadata(source, testSchema); + expect(enrichedSource).toEqual({ + test: c.image("/public/val/images/logo.png", { + width: 800, + height: 600, + mimeType: "image/png", + alt: "An example image", + }), + }); + }); + + test("should enrich deeply nested schema with multiple images, files, records, arrays, unions, and richtext", () => { + const { c, s } = initVal(); + + // Define 3 different images modules + const avatarsModule = c.define( + "/content/avatars.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/avatars", + }), + { + "/public/val/avatars/john.png": { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }, + "/public/val/avatars/jane.png": { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }, + } as Record, + ); + + // Remote images module - uses c.remote() instead of c.image() + const productsModule = c.define( + "/content/products.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/products", + }).remote(), + { + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg": { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg": { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, + } as Record, + ); + + const bannersModule = c.define( + "/content/banners.val.ts", + s.images({ + accept: "image/*", + directory: "/public/val/banners", + }), + { + "/public/val/banners/hero.webp": { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }, + "/public/val/banners/promo.webp": { + width: 1200, + height: 600, + mimeType: "image/webp", + alt: "Promo banner", + }, + } as Record, + ); + + // Define 1 files module + const documentsModule = c.define( + "/content/documents.val.ts", + s.files({ + accept: "application/pdf", + directory: "/public/val/documents", + }), + { + "/public/val/documents/manual.pdf": { + mimeType: "application/pdf", + }, + "/public/val/documents/brochure.pdf": { + mimeType: "application/pdf", + }, + } as Record, + ); + + // Create deeply nested schema with all combinations + const deepSchema = s.object({ + // Simple nested object with image + header: s.object({ + banner: s.image(bannersModule), + }), + + // Record -> Object -> Image + users: s.record( + s.object({ + name: s.string(), + avatar: s.image(avatarsModule), + }), + ), + + // Array -> Object -> Object -> Array -> Image (deep nesting) + products: s.array( + s.object({ + name: s.string(), + details: s.object({ + description: s.string(), + gallery: s.array(s.image(productsModule)), + }), + }), + ), + + // Array -> Union with different types at each variant + contentBlocks: s.array( + s.union( + "type", + s.object({ + type: s.literal("hero"), + backgroundImage: s.image(bannersModule), + }), + s.object({ + type: s.literal("product"), + productImage: s.image(productsModule), + }), + s.object({ + type: s.literal("document"), + file: s.file(documentsModule), + }), + s.object({ + type: s.literal("article"), + body: s.richtext({ + inline: { + img: s.image(productsModule), + }, + }), + }), + ), + ), + + // Union at object level + sidebar: s.union( + "variant", + s.object({ + variant: s.literal("promo"), + promoImage: s.image(bannersModule), + }), + s.object({ + variant: s.literal("download"), + downloadFile: s.file(documentsModule), + }), + ), + + // Deep 3-level object nesting with richtext at bottom + nested: s.object({ + level1: s.object({ + level2: s.object({ + level3: s.object({ + deepImage: s.image(avatarsModule), + richContent: s.richtext({ + inline: { + img: s.image(avatarsModule), + }, + }), + }), + }), + }), + }), + }); + + // Create test data + const testModule = c.define("/content/deep-test.val.ts", deepSchema, { + header: { + banner: c.image("/public/val/banners/hero.webp"), + }, + + users: { + john: { + name: "John Doe", + avatar: c.image("/public/val/avatars/john.png"), + }, + jane: { + name: "Jane Smith", + avatar: c.image("/public/val/avatars/jane.png"), + }, + }, + + products: [ + { + name: "Widget", + details: { + description: "A useful widget", + gallery: [ + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { mimeType: "image/jpeg" }), + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", { mimeType: "image/jpeg" }), + ], + }, + }, + ], + + contentBlocks: [ + { + type: "hero" as const, + backgroundImage: c.image("/public/val/banners/hero.webp"), + }, + { + type: "product" as const, + productImage: c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { mimeType: "image/jpeg" }), + }, + { + type: "document" as const, + file: c.file("/public/val/documents/manual.pdf"), + }, + { + type: "article" as const, + body: [ + { + tag: "p", + children: [ + "Check out this product: ", + { + tag: "img", + src: c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", { mimeType: "image/png" }), + }, + ], + }, + ], + }, + ], + + sidebar: { + variant: "promo" as const, + promoImage: c.image("/public/val/banners/promo.webp"), + }, + + nested: { + level1: { + level2: { + level3: { + deepImage: c.image("/public/val/avatars/john.png"), + richContent: [ + { + tag: "p", + children: [ + "Deep content with image: ", + { + tag: "img", + src: c.image("/public/val/avatars/jane.png"), + }, + ], + }, + ], + }, + }, + }, + }, + }); + + const source = Internal.getSource(testModule); + const enrichedSource = enrichFileImageRemoteSourceWithMetadata( + source, + deepSchema, + ) as typeof source; + + // Verify header banner + expect(enrichedSource.header.banner).toEqual( + c.image("/public/val/banners/hero.webp", { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }), + ); + + // Verify record -> object -> image + expect(enrichedSource.users.john.avatar).toEqual( + c.image("/public/val/avatars/john.png", { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }), + ); + expect(enrichedSource.users.jane.avatar).toEqual( + c.image("/public/val/avatars/jane.png", { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }), + ); + + // Verify array -> object -> object -> array -> remote image + expect(enrichedSource.products[0].details.gallery[0]).toEqual( + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }), + ); + expect(enrichedSource.products[0].details.gallery[1]).toEqual( + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }), + ); + + // Verify array -> union variants + const heroBlock = enrichedSource.contentBlocks[0] as { + type: "hero"; + backgroundImage: ReturnType; + }; + expect(heroBlock.backgroundImage).toEqual( + c.image("/public/val/banners/hero.webp", { + width: 1920, + height: 1080, + mimeType: "image/webp", + alt: "Hero banner", + }), + ); + + const productBlock = enrichedSource.contentBlocks[1] as { + type: "product"; + productImage: ReturnType; + }; + expect(productBlock.productImage).toEqual( + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }), + ); + + const documentBlock = enrichedSource.contentBlocks[2] as { + type: "document"; + file: ReturnType; + }; + expect(documentBlock.file).toEqual( + c.file("/public/val/documents/manual.pdf", { + mimeType: "application/pdf", + }), + ); + + // Verify richtext inline remote image in union + const articleBlock = enrichedSource.contentBlocks[3] as { + type: "article"; + body: Array<{ + tag: string; + children: Array< + string | { tag: string; src: ReturnType } + >; + }>; + }; + const inlineImg = articleBlock.body[0].children[1] as { + tag: string; + src: ReturnType; + }; + expect(inlineImg.src).toEqual( + c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }), + ); + + // Verify sidebar union + const sidebarPromo = enrichedSource.sidebar as { + variant: "promo"; + promoImage: ReturnType; + }; + expect(sidebarPromo.promoImage).toEqual( + c.image("/public/val/banners/promo.webp", { + width: 1200, + height: 600, + mimeType: "image/webp", + alt: "Promo banner", + }), + ); + + // Verify deep nested object with image + expect(enrichedSource.nested.level1.level2.level3.deepImage).toEqual( + c.image("/public/val/avatars/john.png", { + width: 200, + height: 200, + mimeType: "image/png", + alt: "John's avatar", + }), + ); + + // Verify deep nested richtext inline image + const deepRichContent = enrichedSource.nested.level1.level2.level3 + .richContent as Array<{ + tag: string; + children: Array< + string | { tag: string; src: ReturnType } + >; + }>; + const deepInlineImg = deepRichContent[0].children[1] as { + tag: string; + src: ReturnType; + }; + expect(deepInlineImg.src).toEqual( + c.image("/public/val/avatars/jane.png", { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }), + ); + }); +}); diff --git a/packages/core/src/enrichFileImageSourceWithRemote.test.ts b/packages/core/src/enrichFileImageSourceWithRemote.test.ts index 1377af4e8..7727a3e14 100644 --- a/packages/core/src/enrichFileImageSourceWithRemote.test.ts +++ b/packages/core/src/enrichFileImageSourceWithRemote.test.ts @@ -1,10 +1,10 @@ import { initVal } from "./initVal"; -import { enrichFileImageSourceWithRemote } from "./module"; +import { enrichFileImageRemoteSourceWithMetadata } from "./module"; import { FilesEntryMetadata } from "./schema/files"; import { ImagesEntryMetadata } from "./schema/images"; import { Internal } from "."; -describe("enrichFileImageSourceWithRemote", () => { +describe("enrichFileImageRemoteSourceWithMetadata", () => { test("should enrich image source with metadata from images module", () => { const { c, s } = initVal(); @@ -33,7 +33,10 @@ describe("enrichFileImageSourceWithRemote", () => { test: c.image("/public/val/images/logo.png"), }); const source = Internal.getSource(testModule); - const enrichedSource = enrichFileImageSourceWithRemote(source, testSchema); + const enrichedSource = enrichFileImageRemoteSourceWithMetadata( + source, + testSchema, + ); expect(enrichedSource).toEqual({ test: c.image("/public/val/images/logo.png", { width: 800, @@ -70,31 +73,37 @@ describe("enrichFileImageSourceWithRemote", () => { } as Record, ); + // Remote images module - uses c.remote() instead of c.image() const productsModule = c.define( "/content/products.val.ts", - s.images({ - accept: "image/*", - directory: "/public/val/products", - }), + s + .images({ + accept: "image/*", + directory: "/public/val/products", + }) + .remote(), { - "/public/val/products/widget.jpg": { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }, - "/public/val/products/gadget.jpg": { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }, - "/public/val/products/inline-product.png": { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg": + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg": + { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png": + { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, } as Record, ); @@ -243,8 +252,14 @@ describe("enrichFileImageSourceWithRemote", () => { details: { description: "A useful widget", gallery: [ - c.image("/public/val/products/widget.jpg"), - c.image("/public/val/products/gadget.jpg"), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { mimeType: "image/jpeg" }, + ), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", + { mimeType: "image/jpeg" }, + ), ], }, }, @@ -257,7 +272,10 @@ describe("enrichFileImageSourceWithRemote", () => { }, { type: "product" as const, - productImage: c.image("/public/val/products/widget.jpg"), + productImage: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { mimeType: "image/jpeg" }, + ), }, { type: "document" as const, @@ -272,7 +290,10 @@ describe("enrichFileImageSourceWithRemote", () => { "Check out this product: ", { tag: "img", - src: c.image("/public/val/products/inline-product.png"), + src: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", + { mimeType: "image/png" }, + ), }, ], }, @@ -309,7 +330,7 @@ describe("enrichFileImageSourceWithRemote", () => { }); const source = Internal.getSource(testModule); - const enrichedSource = enrichFileImageSourceWithRemote( + const enrichedSource = enrichFileImageRemoteSourceWithMetadata( source, deepSchema, ) as typeof source; @@ -342,22 +363,28 @@ describe("enrichFileImageSourceWithRemote", () => { }), ); - // Verify array -> object -> object -> array -> image + // Verify array -> object -> object -> array -> remote image expect(enrichedSource.products[0].details.gallery[0]).toEqual( - c.image("/public/val/products/widget.jpg", { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + ), ); expect(enrichedSource.products[0].details.gallery[1]).toEqual( - c.image("/public/val/products/gadget.jpg", { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", + { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + ), ); // Verify array -> union variants @@ -376,15 +403,18 @@ describe("enrichFileImageSourceWithRemote", () => { const productBlock = enrichedSource.contentBlocks[1] as { type: "product"; - productImage: ReturnType; + productImage: ReturnType; }; expect(productBlock.productImage).toEqual( - c.image("/public/val/products/widget.jpg", { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + ), ); const documentBlock = enrichedSource.contentBlocks[2] as { @@ -397,27 +427,30 @@ describe("enrichFileImageSourceWithRemote", () => { }), ); - // Verify richtext inline image in union + // Verify richtext inline remote image in union const articleBlock = enrichedSource.contentBlocks[3] as { type: "article"; body: Array<{ tag: string; children: Array< - string | { tag: string; src: ReturnType } + string | { tag: string; src: ReturnType } >; }>; }; const inlineImg = articleBlock.body[0].children[1] as { tag: string; - src: ReturnType; + src: ReturnType; }; expect(inlineImg.src).toEqual( - c.image("/public/val/products/inline-product.png", { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", + { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, + ), ); // Verify sidebar union diff --git a/packages/core/src/module.ts b/packages/core/src/module.ts index 734bd1933..1fe619c18 100644 --- a/packages/core/src/module.ts +++ b/packages/core/src/module.ts @@ -9,7 +9,7 @@ import { Path, } from "./selector"; import { Source } from "./source"; -import { getValPath, ModuleFilePath, ModulePath, SourcePath } from "./val"; +import { ModuleFilePath, ModulePath, SourcePath } from "./val"; import { ArraySchema, SerializedArraySchema } from "./schema/array"; import { UnionSchema, SerializedUnionSchema } from "./schema/union"; import { Json } from "./Json"; @@ -65,7 +65,7 @@ export function define>( } as unknown as ValModule>; } -export function enrichFileImageSourceWithRemote( +export function enrichFileImageRemoteSourceWithMetadata( source: SelectorSource, schema: Schema, ): SelectorSource { From 9f8903678232822a75981aad7b6f7d105a008e97 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 13 Feb 2026 16:06:36 +0000 Subject: [PATCH 06/32] Add agent rules --- .agent/rules.md | 204 ++++++++++++++++++++++++++++++++ .claude/CLAUDE.md | 1 + .cursor/rules/val-rules.md | 1 + .github/copilot-instructions.md | 1 + 4 files changed, 207 insertions(+) create mode 100644 .agent/rules.md create mode 120000 .claude/CLAUDE.md create mode 120000 .cursor/rules/val-rules.md create mode 120000 .github/copilot-instructions.md diff --git a/.agent/rules.md b/.agent/rules.md new file mode 100644 index 000000000..45a4c0338 --- /dev/null +++ b/.agent/rules.md @@ -0,0 +1,204 @@ +# Val Codebase Instructions + +Instructions for AI assistants working with the Val content management system codebase. + +## General rules + +1. Never add @ts-expect-error unless explicitly being allowed to do so +2. Never use as any unless explicitly being allowed to do so +3. Ask if you need to use type assertions (`as Something`) - we try to avoid those + +## Type System Architecture + +### Core Type Hierarchy + +Val has a dual type system: **Source** types define data shape, **Selector** types is the user facing types. + +``` +Source (data) → Selector (access) +───────────────────────────────────────────── +ImageSource → ImageSelector +FileSource → FileSelector +RemoteSource → GenericSelector +RichTextSource → RichTextSelector +SourceObject → ObjectSelector +SourceArray → ArraySelector +string/number/boolean → StringSelector/NumberSelector/BooleanSelector +``` + +### Key Type Definitions + +**Source** (`packages/core/src/source/index.ts`): + +```typescript +export type Source = + | SourcePrimitive // string | number | boolean | null + | SourceObject // { [key: string]: Source } + | SourceArray // readonly Source[] + | RemoteSource + | FileSource + | ImageSource + | RichTextSource; +``` + +**SelectorSource** (`packages/core/src/selector/index.ts`): + +```typescript +export type SelectorSource = + | SourcePrimitive + | undefined + | readonly SelectorSource[] + | { [key: string]: SelectorSource } + | ImageSource + | FileSource + | RemoteSource + | RichTextSource + | GenericSelector; +``` + +**GenericSelector** (`packages/core/src/selector/index.ts`): + +```typescript +class GenericSelector { + [GetSource]: T; // The actual source value + [GetSchema]: Schema | undefined; // Schema for validation + [Path]: SourcePath | undefined; // Path in the module tree + [ValError]: Error | undefined; // Type errors +} +``` + +### CRITICAL: Adding New Source Types + +When adding a new source type, it **MUST** be added to BOTH unions: + +1. `Source` in `packages/core/src/source/index.ts` +2. `SelectorSource` in `packages/core/src/selector/index.ts` + +Additionally: 3. Create selector type in `packages/core/src/selector/{name}.ts` 4. Add mapping in `Selector` conditional type in `packages/core/src/selector/index.ts` + +### FORBIDDEN: Type Intersection Hacks + +**NEVER** use type intersections (`&`) to force a type to satisfy constraints: + +```typescript +// ❌ WRONG - This is a hack that hides the real problem +export type RichTextSelector = GenericSelector & Source>; + +// ✅ CORRECT - Add missing types to SelectorSource union +export type SelectorSource = + | ...existing types... + | ImageSource // Add missing type here +``` + +If you see `Type 'X' does not satisfy the constraint 'Source'`, the fix is almost always adding a type to `SelectorSource`, NOT using intersections. + +## Schema System + +### Schema-Source Relationship + +Each Schema class validates and types its corresponding Source type: + +| Schema | Source | Factory | +| ------------------- | ------------------- | --------------------- | +| `ImageSchema` | `ImageSource` | `s.image()` | +| `FileSchema` | `FileSource` | `s.file()` | +| `RichTextSchema` | `RichTextSource` | `s.richtext(options)` | +| `ObjectSchema` | `SourceObject` | `s.object({...})` | +| `ArraySchema` | `SourceArray` | `s.array(schema)` | + +## Module System + +### c.define() Pattern + +```typescript +c.define( + "/content/page.val.ts", // Module path + s.object({...}), // Schema + { ... } // Source data matching schema +) +``` + +### Source Constructors + +```typescript +c.image("/public/val/logo.png", { + width: 100, + height: 100, + mimeType: "image/png", +}); +c.file("/public/val/doc.pdf", { mimeType: "application/pdf" }); +c.remote("https://...", { mimeType: "image/jpeg" }); +``` + +## UI Architecture + +### Shadow DOM Isolation + +The Val UI runs inside a Shadow DOM for CSS/JS isolation from the host page: + +```typescript +// packages/ui/spa/components/ShadowRoot.tsx +const root = node.attachShadow({ mode: "open" }); +// ID: "val-shadow-root" +``` + +**Implications:** + +- CSS must target `:host` (not `:root`) for shadow DOM styles +- External stylesheets must be loaded inside the shadow root +- `document.querySelector` won't find elements inside shadow DOM +- Use `shadowRoot.querySelector` or React refs instead + +### CSS Architecture + +```css +/* packages/ui/spa/index.css */ +@layer base { + :host, /* Shadow DOM */ + :root { + /* Regular DOM fallback */ + --background: ...; + --foreground: ...; + } +} +``` + +- Dark mode: `[data-mode="dark"]` selector +- CSS loaded via `/api/val/static/{VERSION}/spa/index.css` +- Event `val-css-loaded` dispatched when styles are ready + +### Tailwind Configuration + +```javascript +// packages/ui/tailwind.config.js +darkMode: ["class", '[data-mode="dark"]']; +``` + +Custom color tokens map to CSS variables (e.g., `bg-background` → `var(--background)`). + +## Testing + +Run tests from root dir with: + +```bash +pnpm test # All tests +pnpm test packages/core/src/... # Specific test file +pnpm run -r typecheck # Type checking +pnpm lint +pnpm format +``` + +### Test rules + +1. Never "fix" an issue by changing the test file +2. Prefer to define test data in a type-safe manner using `s` and `c` from `initVal`. Search for examples. + +## Common Fixes + +### "Type 'X' does not satisfy constraint 'Source'" + +→ Add the type to `SelectorSource` union in `packages/core/src/selector/index.ts` + +### "Property 'X' does not exist on type 'never'" + +→ Check if all variants are handled in conditional types (especially in `ImageNode`, `RichTextSource`) diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md new file mode 120000 index 000000000..8d157ee00 --- /dev/null +++ b/.claude/CLAUDE.md @@ -0,0 +1 @@ +../.agent/rules.md \ No newline at end of file diff --git a/.cursor/rules/val-rules.md b/.cursor/rules/val-rules.md new file mode 120000 index 000000000..12477a339 --- /dev/null +++ b/.cursor/rules/val-rules.md @@ -0,0 +1 @@ +../../.agent/rules.md \ No newline at end of file diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md new file mode 120000 index 000000000..8d157ee00 --- /dev/null +++ b/.github/copilot-instructions.md @@ -0,0 +1 @@ +../.agent/rules.md \ No newline at end of file From 7a4fa7cf920caa063e4799a54c841716ab8acbe3 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 13 Feb 2026 16:52:01 +0100 Subject: [PATCH 07/32] Align types after adding s.files and s.images --- ...hFileImageRemoteSourceWithMetadata.test.ts | 261 ++++----- .../enrichFileImageSourceWithRemote.test.ts | 501 ------------------ packages/core/src/module.ts | 15 +- packages/core/src/schema/file.ts | 2 +- packages/core/src/schema/image.ts | 11 +- packages/core/src/schema/richtext.ts | 16 +- packages/core/src/selector/index.ts | 1 + packages/core/src/source/file.ts | 4 +- packages/core/src/source/index.ts | 2 + packages/core/src/source/remote.ts | 2 +- packages/core/src/source/richtext.ts | 8 +- 11 files changed, 175 insertions(+), 648 deletions(-) delete mode 100644 packages/core/src/enrichFileImageSourceWithRemote.test.ts diff --git a/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts b/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts index ecd7b4d8d..87e79c1df 100644 --- a/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts +++ b/packages/core/src/enrichFileImageRemoteSourceWithMetadata.test.ts @@ -1,7 +1,5 @@ import { initVal } from "./initVal"; import { enrichFileImageRemoteSourceWithMetadata } from "./module"; -import { FilesEntryMetadata } from "./schema/files"; -import { ImagesEntryMetadata } from "./schema/images"; import { Internal } from "."; describe("enrichFileImageRemoteSourceWithMetadata", () => { @@ -22,7 +20,7 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { mimeType: "image/png", alt: "An example image", }, - } as Record, + }, ); const testSchema = s.object({ @@ -33,7 +31,10 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { test: c.image("/public/val/images/logo.png"), }); const source = Internal.getSource(testModule); - const enrichedSource = enrichFileImageRemoteSourceWithMetadata(source, testSchema); + const enrichedSource = enrichFileImageRemoteSourceWithMetadata( + source, + testSchema, + ); expect(enrichedSource).toEqual({ test: c.image("/public/val/images/logo.png", { width: 800, @@ -67,36 +68,41 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { mimeType: "image/png", alt: "Jane's avatar", }, - } as Record, + }, ); // Remote images module - uses c.remote() instead of c.image() const productsModule = c.define( "/content/products.val.ts", - s.images({ - accept: "image/*", - directory: "/public/val/products", - }).remote(), + s + .images({ + accept: "image/*", + directory: "/public/val/products", + }) + .remote(), { - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg": { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }, - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg": { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }, - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png": { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }, - } as Record, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg": + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg": + { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png": + { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, + }, ); const bannersModule = c.define( @@ -118,7 +124,7 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { mimeType: "image/webp", alt: "Promo banner", }, - } as Record, + }, ); // Define 1 files module @@ -135,7 +141,7 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { "/public/val/documents/brochure.pdf": { mimeType: "application/pdf", }, - } as Record, + }, ); // Create deeply nested schema with all combinations @@ -244,8 +250,12 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { details: { description: "A useful widget", gallery: [ - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { mimeType: "image/jpeg" }), - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", { mimeType: "image/jpeg" }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + ), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", + ), ], }, }, @@ -253,19 +263,21 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { contentBlocks: [ { - type: "hero" as const, + type: "hero", backgroundImage: c.image("/public/val/banners/hero.webp"), }, { - type: "product" as const, - productImage: c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { mimeType: "image/jpeg" }), + type: "product", + productImage: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + ), }, { - type: "document" as const, + type: "document", file: c.file("/public/val/documents/manual.pdf"), }, { - type: "article" as const, + type: "article", body: [ { tag: "p", @@ -273,7 +285,9 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { "Check out this product: ", { tag: "img", - src: c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", { mimeType: "image/png" }), + src: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", + ), }, ], }, @@ -282,7 +296,7 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { ], sidebar: { - variant: "promo" as const, + variant: "promo", promoImage: c.image("/public/val/banners/promo.webp"), }, @@ -313,7 +327,7 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { const enrichedSource = enrichFileImageRemoteSourceWithMetadata( source, deepSchema, - ) as typeof source; + ); // Verify header banner expect(enrichedSource.header.banner).toEqual( @@ -345,95 +359,94 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { // Verify array -> object -> object -> array -> remote image expect(enrichedSource.products[0].details.gallery[0]).toEqual( - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + ), ); expect(enrichedSource.products[0].details.gallery[1]).toEqual( - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }), + c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", + { + width: 800, + height: 600, + mimeType: "image/jpeg", + alt: "Gadget product", + }, + ), ); // Verify array -> union variants - const heroBlock = enrichedSource.contentBlocks[0] as { - type: "hero"; - backgroundImage: ReturnType; - }; - expect(heroBlock.backgroundImage).toEqual( - c.image("/public/val/banners/hero.webp", { + expect(enrichedSource.contentBlocks[0]).toEqual({ + type: "hero", + backgroundImage: c.image("/public/val/banners/hero.webp", { width: 1920, height: 1080, mimeType: "image/webp", alt: "Hero banner", }), - ); + }); - const productBlock = enrichedSource.contentBlocks[1] as { - type: "product"; - productImage: ReturnType; - }; - expect(productBlock.productImage).toEqual( - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }), - ); + expect(enrichedSource.contentBlocks[1]).toEqual({ + type: "product", + productImage: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", + { + width: 600, + height: 400, + mimeType: "image/jpeg", + alt: "Widget product", + }, + ), + }); - const documentBlock = enrichedSource.contentBlocks[2] as { - type: "document"; - file: ReturnType; - }; - expect(documentBlock.file).toEqual( - c.file("/public/val/documents/manual.pdf", { + expect(enrichedSource.contentBlocks[2]).toEqual({ + type: "document", + file: c.file("/public/val/documents/manual.pdf", { mimeType: "application/pdf", }), - ); + }); // Verify richtext inline remote image in union - const articleBlock = enrichedSource.contentBlocks[3] as { - type: "article"; - body: Array<{ - tag: string; - children: Array< - string | { tag: string; src: ReturnType } - >; - }>; - }; - const inlineImg = articleBlock.body[0].children[1] as { - tag: string; - src: ReturnType; - }; - expect(inlineImg.src).toEqual( - c.remote("https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }), - ); + expect(enrichedSource.contentBlocks[3]).toEqual({ + type: "article", + body: [ + { + tag: "p", + children: [ + "Check out this product: ", + { + tag: "img", + src: c.remote( + "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", + { + width: 100, + height: 100, + mimeType: "image/png", + alt: "Inline product image", + }, + ), + }, + ], + }, + ], + }); // Verify sidebar union - const sidebarPromo = enrichedSource.sidebar as { - variant: "promo"; - promoImage: ReturnType; - }; - expect(sidebarPromo.promoImage).toEqual( - c.image("/public/val/banners/promo.webp", { + expect(enrichedSource.sidebar).toEqual({ + variant: "promo", + promoImage: c.image("/public/val/banners/promo.webp", { width: 1200, height: 600, mimeType: "image/webp", alt: "Promo banner", }), - ); + }); // Verify deep nested object with image expect(enrichedSource.nested.level1.level2.level3.deepImage).toEqual( @@ -446,24 +459,22 @@ describe("enrichFileImageRemoteSourceWithMetadata", () => { ); // Verify deep nested richtext inline image - const deepRichContent = enrichedSource.nested.level1.level2.level3 - .richContent as Array<{ - tag: string; - children: Array< - string | { tag: string; src: ReturnType } - >; - }>; - const deepInlineImg = deepRichContent[0].children[1] as { - tag: string; - src: ReturnType; - }; - expect(deepInlineImg.src).toEqual( - c.image("/public/val/avatars/jane.png", { - width: 150, - height: 150, - mimeType: "image/png", - alt: "Jane's avatar", - }), - ); + expect(enrichedSource.nested.level1.level2.level3.richContent).toEqual([ + { + tag: "p", + children: [ + "Deep content with image: ", + { + tag: "img", + src: c.image("/public/val/avatars/jane.png", { + width: 150, + height: 150, + mimeType: "image/png", + alt: "Jane's avatar", + }), + }, + ], + }, + ]); }); }); diff --git a/packages/core/src/enrichFileImageSourceWithRemote.test.ts b/packages/core/src/enrichFileImageSourceWithRemote.test.ts deleted file mode 100644 index 7727a3e14..000000000 --- a/packages/core/src/enrichFileImageSourceWithRemote.test.ts +++ /dev/null @@ -1,501 +0,0 @@ -import { initVal } from "./initVal"; -import { enrichFileImageRemoteSourceWithMetadata } from "./module"; -import { FilesEntryMetadata } from "./schema/files"; -import { ImagesEntryMetadata } from "./schema/images"; -import { Internal } from "."; - -describe("enrichFileImageRemoteSourceWithMetadata", () => { - test("should enrich image source with metadata from images module", () => { - const { c, s } = initVal(); - - // Define an images module (like media.val.ts) - const imagesModule = c.define( - "/content/images.val.ts", - s.images({ - accept: "image/webp", - directory: "/public/val/images", - }), - { - "/public/val/images/logo.png": { - width: 800, - height: 600, - mimeType: "image/png", - alt: "An example image", - }, - } as Record, - ); - - const testSchema = s.object({ - test: s.image(imagesModule), - }); - - const testModule = c.define("/content/test.val.ts", testSchema, { - test: c.image("/public/val/images/logo.png"), - }); - const source = Internal.getSource(testModule); - const enrichedSource = enrichFileImageRemoteSourceWithMetadata( - source, - testSchema, - ); - expect(enrichedSource).toEqual({ - test: c.image("/public/val/images/logo.png", { - width: 800, - height: 600, - mimeType: "image/png", - alt: "An example image", - }), - }); - }); - - test("should enrich deeply nested schema with multiple images, files, records, arrays, unions, and richtext", () => { - const { c, s } = initVal(); - - // Define 3 different images modules - const avatarsModule = c.define( - "/content/avatars.val.ts", - s.images({ - accept: "image/*", - directory: "/public/val/avatars", - }), - { - "/public/val/avatars/john.png": { - width: 200, - height: 200, - mimeType: "image/png", - alt: "John's avatar", - }, - "/public/val/avatars/jane.png": { - width: 150, - height: 150, - mimeType: "image/png", - alt: "Jane's avatar", - }, - } as Record, - ); - - // Remote images module - uses c.remote() instead of c.image() - const productsModule = c.define( - "/content/products.val.ts", - s - .images({ - accept: "image/*", - directory: "/public/val/products", - }) - .remote(), - { - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg": - { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }, - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg": - { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }, - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png": - { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }, - } as Record, - ); - - const bannersModule = c.define( - "/content/banners.val.ts", - s.images({ - accept: "image/*", - directory: "/public/val/banners", - }), - { - "/public/val/banners/hero.webp": { - width: 1920, - height: 1080, - mimeType: "image/webp", - alt: "Hero banner", - }, - "/public/val/banners/promo.webp": { - width: 1200, - height: 600, - mimeType: "image/webp", - alt: "Promo banner", - }, - } as Record, - ); - - // Define 1 files module - const documentsModule = c.define( - "/content/documents.val.ts", - s.files({ - accept: "application/pdf", - directory: "/public/val/documents", - }), - { - "/public/val/documents/manual.pdf": { - mimeType: "application/pdf", - }, - "/public/val/documents/brochure.pdf": { - mimeType: "application/pdf", - }, - } as Record, - ); - - // Create deeply nested schema with all combinations - const deepSchema = s.object({ - // Simple nested object with image - header: s.object({ - banner: s.image(bannersModule), - }), - - // Record -> Object -> Image - users: s.record( - s.object({ - name: s.string(), - avatar: s.image(avatarsModule), - }), - ), - - // Array -> Object -> Object -> Array -> Image (deep nesting) - products: s.array( - s.object({ - name: s.string(), - details: s.object({ - description: s.string(), - gallery: s.array(s.image(productsModule)), - }), - }), - ), - - // Array -> Union with different types at each variant - contentBlocks: s.array( - s.union( - "type", - s.object({ - type: s.literal("hero"), - backgroundImage: s.image(bannersModule), - }), - s.object({ - type: s.literal("product"), - productImage: s.image(productsModule), - }), - s.object({ - type: s.literal("document"), - file: s.file(documentsModule), - }), - s.object({ - type: s.literal("article"), - body: s.richtext({ - inline: { - img: s.image(productsModule), - }, - }), - }), - ), - ), - - // Union at object level - sidebar: s.union( - "variant", - s.object({ - variant: s.literal("promo"), - promoImage: s.image(bannersModule), - }), - s.object({ - variant: s.literal("download"), - downloadFile: s.file(documentsModule), - }), - ), - - // Deep 3-level object nesting with richtext at bottom - nested: s.object({ - level1: s.object({ - level2: s.object({ - level3: s.object({ - deepImage: s.image(avatarsModule), - richContent: s.richtext({ - inline: { - img: s.image(avatarsModule), - }, - }), - }), - }), - }), - }), - }); - - // Create test data - const testModule = c.define("/content/deep-test.val.ts", deepSchema, { - header: { - banner: c.image("/public/val/banners/hero.webp"), - }, - - users: { - john: { - name: "John Doe", - avatar: c.image("/public/val/avatars/john.png"), - }, - jane: { - name: "Jane Smith", - avatar: c.image("/public/val/avatars/jane.png"), - }, - }, - - products: [ - { - name: "Widget", - details: { - description: "A useful widget", - gallery: [ - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", - { mimeType: "image/jpeg" }, - ), - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", - { mimeType: "image/jpeg" }, - ), - ], - }, - }, - ], - - contentBlocks: [ - { - type: "hero" as const, - backgroundImage: c.image("/public/val/banners/hero.webp"), - }, - { - type: "product" as const, - productImage: c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", - { mimeType: "image/jpeg" }, - ), - }, - { - type: "document" as const, - file: c.file("/public/val/documents/manual.pdf"), - }, - { - type: "article" as const, - body: [ - { - tag: "p", - children: [ - "Check out this product: ", - { - tag: "img", - src: c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", - { mimeType: "image/png" }, - ), - }, - ], - }, - ], - }, - ], - - sidebar: { - variant: "promo" as const, - promoImage: c.image("/public/val/banners/promo.webp"), - }, - - nested: { - level1: { - level2: { - level3: { - deepImage: c.image("/public/val/avatars/john.png"), - richContent: [ - { - tag: "p", - children: [ - "Deep content with image: ", - { - tag: "img", - src: c.image("/public/val/avatars/jane.png"), - }, - ], - }, - ], - }, - }, - }, - }, - }); - - const source = Internal.getSource(testModule); - const enrichedSource = enrichFileImageRemoteSourceWithMetadata( - source, - deepSchema, - ) as typeof source; - - // Verify header banner - expect(enrichedSource.header.banner).toEqual( - c.image("/public/val/banners/hero.webp", { - width: 1920, - height: 1080, - mimeType: "image/webp", - alt: "Hero banner", - }), - ); - - // Verify record -> object -> image - expect(enrichedSource.users.john.avatar).toEqual( - c.image("/public/val/avatars/john.png", { - width: 200, - height: 200, - mimeType: "image/png", - alt: "John's avatar", - }), - ); - expect(enrichedSource.users.jane.avatar).toEqual( - c.image("/public/val/avatars/jane.png", { - width: 150, - height: 150, - mimeType: "image/png", - alt: "Jane's avatar", - }), - ); - - // Verify array -> object -> object -> array -> remote image - expect(enrichedSource.products[0].details.gallery[0]).toEqual( - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", - { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }, - ), - ); - expect(enrichedSource.products[0].details.gallery[1]).toEqual( - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/gadget456/p/public/val/products/gadget.jpg", - { - width: 800, - height: 600, - mimeType: "image/jpeg", - alt: "Gadget product", - }, - ), - ); - - // Verify array -> union variants - const heroBlock = enrichedSource.contentBlocks[0] as { - type: "hero"; - backgroundImage: ReturnType; - }; - expect(heroBlock.backgroundImage).toEqual( - c.image("/public/val/banners/hero.webp", { - width: 1920, - height: 1080, - mimeType: "image/webp", - alt: "Hero banner", - }), - ); - - const productBlock = enrichedSource.contentBlocks[1] as { - type: "product"; - productImage: ReturnType; - }; - expect(productBlock.productImage).toEqual( - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/widget123/p/public/val/products/widget.jpg", - { - width: 600, - height: 400, - mimeType: "image/jpeg", - alt: "Widget product", - }, - ), - ); - - const documentBlock = enrichedSource.contentBlocks[2] as { - type: "document"; - file: ReturnType; - }; - expect(documentBlock.file).toEqual( - c.file("/public/val/documents/manual.pdf", { - mimeType: "application/pdf", - }), - ); - - // Verify richtext inline remote image in union - const articleBlock = enrichedSource.contentBlocks[3] as { - type: "article"; - body: Array<{ - tag: string; - children: Array< - string | { tag: string; src: ReturnType } - >; - }>; - }; - const inlineImg = articleBlock.body[0].children[1] as { - tag: string; - src: ReturnType; - }; - expect(inlineImg.src).toEqual( - c.remote( - "https://example.com/file/p/test/b/default/v/1.0.0/h/abc123/f/inline789/p/public/val/products/inline-product.png", - { - width: 100, - height: 100, - mimeType: "image/png", - alt: "Inline product image", - }, - ), - ); - - // Verify sidebar union - const sidebarPromo = enrichedSource.sidebar as { - variant: "promo"; - promoImage: ReturnType; - }; - expect(sidebarPromo.promoImage).toEqual( - c.image("/public/val/banners/promo.webp", { - width: 1200, - height: 600, - mimeType: "image/webp", - alt: "Promo banner", - }), - ); - - // Verify deep nested object with image - expect(enrichedSource.nested.level1.level2.level3.deepImage).toEqual( - c.image("/public/val/avatars/john.png", { - width: 200, - height: 200, - mimeType: "image/png", - alt: "John's avatar", - }), - ); - - // Verify deep nested richtext inline image - const deepRichContent = enrichedSource.nested.level1.level2.level3 - .richContent as Array<{ - tag: string; - children: Array< - string | { tag: string; src: ReturnType } - >; - }>; - const deepInlineImg = deepRichContent[0].children[1] as { - tag: string; - src: ReturnType; - }; - expect(deepInlineImg.src).toEqual( - c.image("/public/val/avatars/jane.png", { - width: 150, - height: 150, - mimeType: "image/png", - alt: "Jane's avatar", - }), - ); - }); -}); diff --git a/packages/core/src/module.ts b/packages/core/src/module.ts index 1fe619c18..84c45f3f3 100644 --- a/packages/core/src/module.ts +++ b/packages/core/src/module.ts @@ -65,10 +65,9 @@ export function define>( } as unknown as ValModule>; } -export function enrichFileImageRemoteSourceWithMetadata( - source: SelectorSource, - schema: Schema, -): SelectorSource { +export function enrichFileImageRemoteSourceWithMetadata< + T extends SelectorSource, +>(source: T, schema: Schema): T { const addedModules = new Set(); let filesLookup: Record = {}; function traverseSchema(schema: Schema) { @@ -141,10 +140,10 @@ export function enrichFileImageRemoteSourceWithMetadata( return source; } -export function getSource(valModule: ValModule): Source { - const sourceOrExpr = valModule[GetSource]; - const source = sourceOrExpr; - return source; +export function getSource( + valModule: ValModule, +): T { + return valModule[GetSource] as T; } export function splitModuleFilePathAndModulePath( diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index 1fec651cf..a2f0dfa94 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -336,7 +336,7 @@ export class FileSchema< export const file = ( options?: FileOptions | ValModule>, ...args: ValModule>[] -): FileSchema> => { +): FileSchema> => { const isModule = !!Internal.getValPath( options as ValModule>, ); diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index 780829ab0..cae4d68c9 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -35,9 +35,10 @@ export type SerializedImageSchema = { moduleMetadata?: Record>; }; -export type ImageMetadata = FileMetadata & { - width: number; - height: number; +export type ImageMetadata = { + width?: number; + height?: number; + mimeType?: string; alt?: string; hotspot?: { x: number; @@ -168,7 +169,7 @@ export class ImageSchema< } const { accept } = this.options || {}; - const { mimeType } = src.metadata || {}; + const mimeType = src.metadata?.mimeType ?? ""; if (accept && mimeType && !mimeType.includes("/")) { return { @@ -373,7 +374,7 @@ export class ImageSchema< export const image = ( options?: ImageOptions | ValModule>, ...args: ValModule>[] -): ImageSchema => { +): ImageSchema> => { const isModule = !!Internal.getValPath( options as ValModule>, ); diff --git a/packages/core/src/schema/richtext.ts b/packages/core/src/schema/richtext.ts index fd28085a1..b8273652c 100644 --- a/packages/core/src/schema/richtext.ts +++ b/packages/core/src/schema/richtext.ts @@ -8,13 +8,14 @@ import { import { ReifiedRender } from "../render"; import { unsafeCreateSourcePath } from "../selector/SelectorProxy"; import { ImageSource } from "../source/image"; +import { RemoteSource } from "../source/remote"; import { RichTextSource, RichTextOptions, SerializedRichTextOptions, } from "../source/richtext"; import { SourcePath } from "../val"; -import { ImageSchema, SerializedImageSchema } from "./image"; +import { ImageMetadata, ImageSchema, SerializedImageSchema } from "./image"; import { RouteSchema, SerializedRouteSchema } from "./route"; import { SerializedStringSchema, StringSchema } from "./string"; import { @@ -298,11 +299,18 @@ export class RichTextSchema< }; } const srcPath = unsafeCreateSourcePath(path, "src"); + const imgSchema = this.options.inline?.img; const imageValidationErrors = - typeof this.options.inline?.img === "object" - ? this.options.inline?.img["executeValidate"]( + typeof imgSchema === "object" + ? ( + imgSchema as ImageSchema< + ImageSource | RemoteSource + > + )["executeValidate"]( srcPath, - node.src as ImageSource, + node.src as + | ImageSource + | RemoteSource, ) : new ImageSchema({}, false, false)["executeValidate"]( srcPath, diff --git a/packages/core/src/selector/index.ts b/packages/core/src/selector/index.ts index 3fe3bbd80..fc3e676ae 100644 --- a/packages/core/src/selector/index.ts +++ b/packages/core/src/selector/index.ts @@ -45,6 +45,7 @@ export type SelectorSource = | { [key: string]: SelectorSource; } + | ImageSource | FileSource | RemoteSource | RichTextSource diff --git a/packages/core/src/source/file.ts b/packages/core/src/source/file.ts index 98f41707c..e8e00e632 100644 --- a/packages/core/src/source/file.ts +++ b/packages/core/src/source/file.ts @@ -5,7 +5,9 @@ import { Json } from "../Json"; export const FILE_REF_PROP = "_ref" as const; export const FILE_REF_SUBTYPE_TAG = "_tag" as const; // TODO: used earlier by c.rt.image, when we remove c.rt we can remove this -export type FileMetadata = { mimeType?: string }; +export type FileMetadata = { + mimeType?: string; +}; /** * A file source represents the path to a (local) file. diff --git a/packages/core/src/source/index.ts b/packages/core/src/source/index.ts index a5432a125..47de4448a 100644 --- a/packages/core/src/source/index.ts +++ b/packages/core/src/source/index.ts @@ -1,4 +1,5 @@ import { FileSource } from "./file"; +import { ImageSource } from "./image"; import { RemoteSource } from "./remote"; import { RichTextOptions, RichTextSource } from "./richtext"; @@ -8,6 +9,7 @@ export type Source = | SourceArray | RemoteSource | FileSource + | ImageSource | RichTextSource; export type SourceObject = { [key in string]: Source } & { diff --git a/packages/core/src/source/remote.ts b/packages/core/src/source/remote.ts index 602874b93..56b25130e 100644 --- a/packages/core/src/source/remote.ts +++ b/packages/core/src/source/remote.ts @@ -19,7 +19,7 @@ export type RemoteSource< export const initRemote = (config?: ValConfig) => { function remote( ref: RemoteRef, - metadata: Metadata, + metadata?: Metadata, ): RemoteSource { return { [FILE_REF_PROP]: ref, diff --git a/packages/core/src/source/richtext.ts b/packages/core/src/source/richtext.ts index d9dc2a659..efdbf1529 100644 --- a/packages/core/src/source/richtext.ts +++ b/packages/core/src/source/richtext.ts @@ -29,7 +29,11 @@ export type RichTextOptions = Partial<{ }>; inline: Partial<{ a: boolean | RouteSchema | StringSchema; - img: boolean | ImageSchema>; + img: + | boolean + | ImageSchema + | ImageSchema> + | ImageSchema>; // custom: Record>; }>; }>; @@ -142,7 +146,7 @@ export type ImageNode = NonNullable< >["img"] extends true ? { tag: "img"; src: ImageSource | RemoteSource } : NonNullable["img"] extends ImageSchema - ? Src extends RemoteSource | FileSource + ? Src extends RemoteSource | FileSource | ImageSource ? { tag: "img"; src: Src } : never : never; From bcc5c57e209f3aa9eda036fd9117f2595dd9460c Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 20 Feb 2026 18:09:21 +0000 Subject: [PATCH 08/32] Fix minor issue related to new files / images --- packages/core/src/schema/file.ts | 8 +++++--- packages/core/src/schema/image.ts | 8 +++++--- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index a2f0dfa94..7c9fdca6a 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -337,9 +337,11 @@ export const file = ( options?: FileOptions | ValModule>, ...args: ValModule>[] ): FileSchema> => { - const isModule = !!Internal.getValPath( - options as ValModule>, - ); + const isModule = + !!options && + !!Internal.getValPath( + options as ValModule>, + ); if (isModule) { const allModules: Record> = {}; for (const valModule of [ diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index cae4d68c9..2c17a005c 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -375,9 +375,11 @@ export const image = ( options?: ImageOptions | ValModule>, ...args: ValModule>[] ): ImageSchema> => { - const isModule = !!Internal.getValPath( - options as ValModule>, - ); + const isModule = + !!options && + !!Internal.getValPath( + options as ValModule>, + ); if (isModule) { const allModules: Record> = {}; for (const valModule of [ From 67d49c8e90e96f7b996f9297f765cd911b96ef70 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 23 Feb 2026 17:59:18 +0000 Subject: [PATCH 09/32] Add media picker, gallery components --- packages/core/src/schema/file.ts | 5 + .../MediaPicker/GalleryUploadTarget.tsx | 97 +++++ .../components/MediaPicker/MediaPicker.tsx | 352 ++++++++++++++++++ .../ui/spa/components/MediaPicker/index.ts | 4 + .../stories/GalleryUploadTarget.stories.tsx | 92 +++++ .../stories/MediaPicker.stories.tsx | 322 ++++++++++++++++ .../ui/spa/components/fields/FileField.tsx | 38 +- .../ui/spa/components/fields/ImageField.tsx | 38 ++ 8 files changed, 947 insertions(+), 1 deletion(-) create mode 100644 packages/ui/spa/components/MediaPicker/GalleryUploadTarget.tsx create mode 100644 packages/ui/spa/components/MediaPicker/MediaPicker.tsx create mode 100644 packages/ui/spa/components/MediaPicker/index.ts create mode 100644 packages/ui/spa/components/MediaPicker/stories/GalleryUploadTarget.stories.tsx create mode 100644 packages/ui/spa/components/MediaPicker/stories/MediaPicker.stories.tsx diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index 7c9fdca6a..7050b11a5 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -28,6 +28,7 @@ export type SerializedFileSchema = { remote?: boolean; opt: boolean; customValidate?: boolean; + moduleMetadata?: Record>; }; export type FileMetadata = { @@ -325,6 +326,10 @@ export class FileSchema< customValidate: this.customValidateFunctions && this.customValidateFunctions?.length > 0, + moduleMetadata: + this.moduleMetadata && Object.keys(this.moduleMetadata).length > 0 + ? this.moduleMetadata + : undefined, }; } diff --git a/packages/ui/spa/components/MediaPicker/GalleryUploadTarget.tsx b/packages/ui/spa/components/MediaPicker/GalleryUploadTarget.tsx new file mode 100644 index 000000000..d5bde7885 --- /dev/null +++ b/packages/ui/spa/components/MediaPicker/GalleryUploadTarget.tsx @@ -0,0 +1,97 @@ +import * as React from "react"; +import { + Select, + SelectContent, + SelectItem, + SelectTrigger, + SelectValue, +} from "../designSystem/select"; +import { Folder } from "lucide-react"; + +export interface GalleryUploadTargetProps { + modulePaths: string[]; + selectedPath?: string; + onSelect?: (path: string) => void; + /** Portal container for the select dropdown (shadow DOM support) */ + portalContainer?: HTMLElement | null; +} + +/** + * Derive a human-friendly display name from a module path. + * + * Examples: + * "/content/media.val.ts" → "media" + * "/content/blog-images.val.ts" → "blog images" + * "/content/pages/hero.val.ts" → "pages / hero" + * "/schema/product_photos.val.ts" → "product photos" + */ +export function prettyModuleName(modulePath: string): string { + // Strip leading slash and the .val.ts (or .val.js) suffix + const stripped = modulePath + .replace(/^\//, "") + .replace(/\.val\.(ts|js)$/, ""); + + // Split on "/" to get folder segments + const segments = stripped.split("/"); + + // Drop "content" or "schema" if it's the first segment and there's more + if ( + segments.length > 1 && + (segments[0] === "content" || segments[0] === "schema") + ) { + segments.shift(); + } + + // Replace dashes/underscores with spaces in each segment and join with " / " + return segments.map((s) => s.replace(/[-_]/g, " ")).join(" / "); +} + +/** + * When multiple gallery modules are referenced by a field, + * this lets the user pick which gallery uploaded files should be added to. + */ +export function GalleryUploadTarget({ + modulePaths, + selectedPath, + onSelect, + portalContainer, +}: GalleryUploadTargetProps) { + const [value, setValue] = React.useState(selectedPath || modulePaths[0]); + + return ( +
+ Add uploads to: + +
+ ); +} diff --git a/packages/ui/spa/components/MediaPicker/MediaPicker.tsx b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx new file mode 100644 index 000000000..ca6d8d0d2 --- /dev/null +++ b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx @@ -0,0 +1,352 @@ +import * as React from "react"; +import { useVirtualizer } from "@tanstack/react-virtual"; +import { + Popover, + PopoverContent, + PopoverTrigger, +} from "../designSystem/popover"; +import { Button } from "../designSystem/button"; +import { cn } from "../designSystem/cn"; +import { Check, ChevronsUpDown, ImageIcon, FileIcon, Search } from "lucide-react"; +import { prettyModuleName } from "./GalleryUploadTarget"; + +export interface GalleryEntry { + /** The file path key (e.g. "/public/val/images/logo.png") */ + filePath: string; + /** Metadata for the entry */ + metadata: Record; + /** Which module this entry belongs to */ + modulePath: string; +} + +export interface MediaPickerProps { + /** Gallery entries grouped by module: Record> */ + moduleEntries: Record>>; + /** Currently selected file ref, if any */ + selectedRef?: string | null; + /** Called when user selects a gallery entry */ + onSelect: (entry: GalleryEntry) => void; + /** Whether this is for images (shows thumbnails) or files */ + isImage?: boolean; + disabled?: boolean; + /** Portal container for the popover (shadow DOM support) */ + portalContainer?: HTMLElement | null; +} + +const ROW_HEIGHT = 48; + +/** A flat row for the virtualized list. Can be a heading or an entry. */ +type PickerRow = + | { kind: "heading"; modulePath: string } + | { kind: "entry"; filePath: string; metadata: Record; modulePath: string }; + +function buildRows( + moduleEntries: Record>>, + filter: string, + showHeadings: boolean, +): PickerRow[] { + const rows: PickerRow[] = []; + const lowerFilter = filter.toLowerCase(); + + for (const modulePath of Object.keys(moduleEntries)) { + const entries = moduleEntries[modulePath]; + const filtered = Object.keys(entries).filter((fp) => { + if (!lowerFilter) return true; + const filename = fp.split("/").pop() || fp; + const alt = + typeof entries[fp].alt === "string" ? (entries[fp].alt as string) : ""; + return ( + filename.toLowerCase().includes(lowerFilter) || + alt.toLowerCase().includes(lowerFilter) + ); + }); + + if (filtered.length === 0) continue; + + if (showHeadings) { + rows.push({ kind: "heading", modulePath }); + } + + for (const filePath of filtered) { + rows.push({ + kind: "entry", + filePath, + metadata: entries[filePath] || {}, + modulePath, + }); + } + } + + return rows; +} + +export function MediaPicker({ + moduleEntries, + selectedRef, + onSelect, + isImage = false, + disabled = false, + portalContainer, +}: MediaPickerProps) { + const [open, setOpen] = React.useState(false); + const [filter, setFilter] = React.useState(""); + const [activeIndex, setActiveIndex] = React.useState(-1); + + const inputRef = React.useRef(null); + const scrollRef = React.useRef(null); + + const modulePaths = Object.keys(moduleEntries); + const showHeadings = modulePaths.length > 1; + + const rows = React.useMemo( + () => buildRows(moduleEntries, filter, showHeadings), + [moduleEntries, filter, showHeadings], + ); + + // Only entry rows are selectable + const entryIndices = React.useMemo( + () => + rows.reduce((acc, row, i) => { + if (row.kind === "entry") acc.push(i); + return acc; + }, []), + [rows], + ); + + const virtualizer = useVirtualizer({ + count: rows.length, + getScrollElement: () => scrollRef.current, + estimateSize: (index) => (rows[index].kind === "heading" ? 28 : ROW_HEIGHT), + overscan: 10, + }); + + // Reset active index when filter changes + React.useEffect(() => { + setActiveIndex(entryIndices.length > 0 ? entryIndices[0] : -1); + }, [filter, entryIndices]); + + // Focus input and re-measure virtualizer when opening + React.useEffect(() => { + if (open) { + // Delay until after the popover open animation completes so the + // scroll container has its real dimensions for the virtualizer. + const t = setTimeout(() => { + inputRef.current?.focus(); + virtualizer.measure(); + }, 100); + return () => clearTimeout(t); + } else { + setFilter(""); + setActiveIndex(-1); + } + }, [open, virtualizer]); + + const selectRow = React.useCallback( + (index: number) => { + const row = rows[index]; + if (row?.kind === "entry") { + onSelect({ + filePath: row.filePath, + metadata: row.metadata, + modulePath: row.modulePath, + }); + setOpen(false); + } + }, + [rows, onSelect], + ); + + const handleKeyDown = React.useCallback( + (e: React.KeyboardEvent) => { + if (entryIndices.length === 0) return; + + const currentPos = entryIndices.indexOf(activeIndex); + + if (e.key === "ArrowDown") { + e.preventDefault(); + const next = + currentPos < entryIndices.length - 1 + ? entryIndices[currentPos + 1] + : entryIndices[0]; + setActiveIndex(next); + virtualizer.scrollToIndex(next, { align: "auto" }); + } else if (e.key === "ArrowUp") { + e.preventDefault(); + const prev = + currentPos > 0 + ? entryIndices[currentPos - 1] + : entryIndices[entryIndices.length - 1]; + setActiveIndex(prev); + virtualizer.scrollToIndex(prev, { align: "auto" }); + } else if (e.key === "Enter") { + e.preventDefault(); + if (activeIndex >= 0) { + selectRow(activeIndex); + } + } else if (e.key === "Escape") { + setOpen(false); + } + }, + [entryIndices, activeIndex, virtualizer, selectRow], + ); + + if (modulePaths.length === 0) { + return null; + } + + const selectedFilename = selectedRef + ? selectedRef.split("/").pop() || selectedRef + : null; + + const totalEntries = Object.values(moduleEntries).reduce( + (sum, entries) => sum + Object.keys(entries).length, + 0, + ); + + const maxHeight = Math.min(totalEntries * ROW_HEIGHT + 60, 320); + + return ( + + + + + + {/* Search input */} +
+ + setFilter(e.target.value)} + onKeyDown={handleKeyDown} + placeholder={isImage ? "Search images..." : "Search files..."} + className="flex h-10 w-full bg-transparent py-3 text-sm outline-none placeholder:text-fg-secondary disabled:cursor-not-allowed disabled:opacity-50" + /> +
+ + {/* Virtualized list */} + {rows.length === 0 ? ( +
+ {isImage ? "No images found." : "No files found."} +
+ ) : ( +
+
+ {virtualizer.getVirtualItems().map((virtualRow) => { + const row = rows[virtualRow.index]; + + if (row.kind === "heading") { + return ( +
+ {prettyModuleName(row.modulePath)} +
+ ); + } + + const filename = + row.filePath.split("/").pop() || row.filePath; + const isSelected = selectedRef === row.filePath; + const isActive = virtualRow.index === activeIndex; + const alt = + typeof row.metadata.alt === "string" + ? row.metadata.alt + : undefined; + const mimeType = + typeof row.metadata.mimeType === "string" + ? row.metadata.mimeType + : undefined; + + return ( +
setActiveIndex(virtualRow.index)} + onClick={() => selectRow(virtualRow.index)} + > + + {isImage && mimeType?.startsWith("image/") ? ( +
+ {alt +
+ ) : ( +
+ {isImage ? ( + + ) : ( + + )} +
+ )} +
+ {filename} + {alt && ( + + {alt} + + )} +
+
+ ); + })} +
+
+ )} + + + ); +} diff --git a/packages/ui/spa/components/MediaPicker/index.ts b/packages/ui/spa/components/MediaPicker/index.ts new file mode 100644 index 000000000..1e883100c --- /dev/null +++ b/packages/ui/spa/components/MediaPicker/index.ts @@ -0,0 +1,4 @@ +export { MediaPicker } from "./MediaPicker"; +export { GalleryUploadTarget, prettyModuleName } from "./GalleryUploadTarget"; +export type { GalleryEntry, MediaPickerProps } from "./MediaPicker"; +export type { GalleryUploadTargetProps } from "./GalleryUploadTarget"; diff --git a/packages/ui/spa/components/MediaPicker/stories/GalleryUploadTarget.stories.tsx b/packages/ui/spa/components/MediaPicker/stories/GalleryUploadTarget.stories.tsx new file mode 100644 index 000000000..677a2d8e3 --- /dev/null +++ b/packages/ui/spa/components/MediaPicker/stories/GalleryUploadTarget.stories.tsx @@ -0,0 +1,92 @@ +import type { Meta, StoryObj } from "@storybook/react"; +import { useState } from "react"; +import { GalleryUploadTarget } from "../GalleryUploadTarget"; + +const meta: Meta = { + title: "Components/MediaPicker/GalleryUploadTarget", + component: GalleryUploadTarget, + parameters: { + layout: "centered", + }, + tags: ["autodocs"], +}; + +export default meta; +type Story = StoryObj; + +export const TwoModules: Story = { + render: function Render() { + const [selected, setSelected] = useState("/content/media.val.ts"); + return ( +
+ +

+ Raw path: {selected} +

+
+ ); + }, +}; + +export const ThreeModules: Story = { + render: function Render() { + const [selected, setSelected] = useState("/content/media.val.ts"); + return ( +
+ +
+ ); + }, +}; + +export const NestedModulePaths: Story = { + render: function Render() { + const [selected, setSelected] = useState( + "/content/pages/hero-images.val.ts", + ); + return ( +
+ +

+ Shows: "pages / hero images", "pages / gallery", "product photos" +

+
+ ); + }, +}; + +export const DefaultSelection: Story = { + render: () => ( +
+ +
+ ), +}; diff --git a/packages/ui/spa/components/MediaPicker/stories/MediaPicker.stories.tsx b/packages/ui/spa/components/MediaPicker/stories/MediaPicker.stories.tsx new file mode 100644 index 000000000..c94f68ac4 --- /dev/null +++ b/packages/ui/spa/components/MediaPicker/stories/MediaPicker.stories.tsx @@ -0,0 +1,322 @@ +import type { Meta, StoryObj } from "@storybook/react"; +import { useState } from "react"; +import { MediaPicker } from "../MediaPicker"; +import type { GalleryEntry } from "../MediaPicker"; + +const meta: Meta = { + title: "Components/MediaPicker", + component: MediaPicker, + parameters: { + layout: "centered", + }, + tags: ["autodocs"], +}; + +export default meta; +type Story = StoryObj; + +const singleModuleImages: Record< + string, + Record> +> = { + "/content/media.val.ts": { + "/public/val/images/logo.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "Company logo", + }, + "/public/val/images/hero.jpg": { + width: 1920, + height: 1080, + mimeType: "image/jpeg", + alt: "Hero banner image", + }, + "/public/val/images/team.webp": { + width: 640, + height: 480, + mimeType: "image/webp", + alt: "Team photo", + }, + "/public/val/images/product-shot.png": { + width: 1200, + height: 900, + mimeType: "image/png", + alt: "Product screenshot", + }, + }, +}; + +const multiModuleImages: Record< + string, + Record> +> = { + "/content/media.val.ts": { + "/public/val/images/logo.png": { + width: 800, + height: 600, + mimeType: "image/png", + alt: "Company logo", + }, + "/public/val/images/hero.jpg": { + width: 1920, + height: 1080, + mimeType: "image/jpeg", + alt: "Hero banner", + }, + }, + "/content/blog-images.val.ts": { + "/public/val/blog/post-1.jpg": { + width: 800, + height: 400, + mimeType: "image/jpeg", + alt: "Blog post 1 cover", + }, + "/public/val/blog/post-2.png": { + width: 1200, + height: 630, + mimeType: "image/png", + alt: "Blog post 2 cover", + }, + "/public/val/blog/thumbnail.webp": { + width: 300, + height: 300, + mimeType: "image/webp", + }, + }, +}; + +const singleModuleFiles: Record< + string, + Record> +> = { + "/content/documents.val.ts": { + "/public/val/docs/readme.pdf": { + mimeType: "application/pdf", + }, + "/public/val/docs/guide.pdf": { + mimeType: "application/pdf", + }, + "/public/val/docs/changelog.txt": { + mimeType: "text/plain", + }, + "/public/val/docs/data.json": { + mimeType: "application/json", + }, + }, +}; + +export const ImageGallery: Story = { + render: function Render() { + const [selected, setSelected] = useState(null); + return ( +
+ setSelected(entry.filePath)} + isImage + /> + {selected && ( +

+ Selected: {selected} +

+ )} +
+ ); + }, +}; + +export const ImageGalleryPreselected: Story = { + render: () => ( +
+ {}} + isImage + /> +
+ ), +}; + +export const MultipleModules: Story = { + render: function Render() { + const [selected, setSelected] = useState(null); + const [lastModule, setLastModule] = useState(null); + return ( +
+ { + setSelected(entry.filePath); + setLastModule(entry.modulePath); + }} + isImage + /> + {selected && ( +
+

Selected: {selected}

+

From: {lastModule}

+
+ )} +
+ ); + }, +}; + +export const FileGallery: Story = { + render: function Render() { + const [selected, setSelected] = useState(null); + return ( +
+ setSelected(entry.filePath)} + isImage={false} + /> + {selected && ( +

+ Selected: {selected} +

+ )} +
+ ); + }, +}; + +export const Disabled: Story = { + render: () => ( +
+ {}} + isImage + disabled + /> +
+ ), +}; + +export const EmptyGallery: Story = { + render: () => ( +
+ {}} + isImage + /> +
+ ), +}; + +export const NoModules: Story = { + render: () => ( +
+ {}} isImage /> +
+ ), +}; + +/** + * Generate a large set of gallery entries for virtualization testing. + * Creates `count` images spread across `moduleCount` modules. + */ +function generateManyImages( + count: number, + moduleCount = 1, +): Record>> { + const folders = [ + "photos", + "banners", + "icons", + "backgrounds", + "avatars", + "screenshots", + "illustrations", + "thumbnails", + ]; + const extensions = ["jpg", "png", "webp"]; + const widths = [800, 1200, 1920, 640, 400, 300]; + const heights = [600, 800, 1080, 480, 400, 300]; + + const modules: Record>> = {}; + + for (let m = 0; m < moduleCount; m++) { + const modName = + moduleCount === 1 + ? "/content/media.val.ts" + : `/content/${folders[m % folders.length]}-gallery.val.ts`; + modules[modName] = {}; + } + + const moduleKeys = Object.keys(modules); + for (let i = 0; i < count; i++) { + const mod = moduleKeys[i % moduleKeys.length]; + const folder = folders[i % folders.length]; + const ext = extensions[i % extensions.length]; + const w = widths[i % widths.length]; + const h = heights[i % heights.length]; + + modules[mod][`/public/val/images/${folder}/image-${i + 1}.${ext}`] = { + width: w, + height: h, + mimeType: `image/${ext === "jpg" ? "jpeg" : ext}`, + alt: `${folder} image ${i + 1}`, + }; + } + + return modules; +} + +export const VirtualizedLargeGallery: Story = { + render: function Render() { + const [selected, setSelected] = useState(null); + const manyImages = generateManyImages(500); + return ( +
+

+ 500 images, virtualized list +

+ setSelected(entry.filePath)} + isImage + /> + {selected && ( +

+ Selected: {selected} +

+ )} +
+ ); + }, +}; + +export const VirtualizedMultiModule: Story = { + render: function Render() { + const [selected, setSelected] = useState(null); + const manyImages = generateManyImages(300, 4); + return ( +
+

+ 300 images across 4 modules, virtualized with headings +

+ setSelected(entry.filePath)} + isImage + /> + {selected && ( +

+ Selected: {selected} +

+ )} +
+ ); + }, +}; diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index c1165c145..55552ca4d 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -34,6 +34,9 @@ import { Button } from "../designSystem/button"; import { useState } from "react"; import { getFileExt } from "../../utils/getFileExt"; import { useEffect } from "react"; +import { useValPortal } from "../ValPortalProvider"; +import { MediaPicker } from "../MediaPicker/MediaPicker"; +import type { GalleryEntry } from "../MediaPicker/MediaPicker"; const textEncoder = new TextEncoder(); export async function createFilePatch( @@ -114,7 +117,9 @@ export function FileField({ path }: { path: SourcePath }) { const [error, setError] = useState(null); const [url, setUrl] = useState(null); const [loading, setLoading] = useState(false); - const { patchPath, addAndUploadPatchWithFileOps } = useAddPatch(path); + const { addPatch, patchPath, addAndUploadPatchWithFileOps } = + useAddPatch(path); + const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( null, ); @@ -266,6 +271,37 @@ export function FileField({ path }: { path: SourcePath }) { )}
)} + {schemaAtPath.data.moduleMetadata && + Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( + > + > + } + selectedRef={source?._ref ?? null} + onSelect={(entry: GalleryEntry) => { + addPatch( + [ + { + op: "replace", + path: patchPath, + value: { + [FILE_REF_PROP]: entry.filePath, + [VAL_EXTENSION]: "file", + metadata: entry.metadata, + }, + }, + ], + "file", + ); + }} + isImage={false} + disabled={disabled} + portalContainer={portalContainer} + /> + )}
{source && (showAsVideo ? ( diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index 35314ea6c..b692be5d8 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -3,6 +3,8 @@ import { Internal, SourcePath, VAL_EXTENSION, + FILE_REF_PROP, + FILE_REF_SUBTYPE_TAG, } from "@valbuild/core"; import { FieldLoading } from "../../components/FieldLoading"; import { FieldNotFound } from "../../components/FieldNotFound"; @@ -27,6 +29,9 @@ import { useEffect, useState } from "react"; import { Input } from "../designSystem/input"; import { Loader2 } from "lucide-react"; import { Button } from "../designSystem/button"; +import { useValPortal } from "../ValPortalProvider"; +import { MediaPicker } from "../MediaPicker/MediaPicker"; +import type { GalleryEntry } from "../MediaPicker/MediaPicker"; export function ImageField({ path }: { path: SourcePath }) { const type = "image"; @@ -43,6 +48,7 @@ export function ImageField({ path }: { path: SourcePath }) { const [loading, setLoading] = useState(false); const { addPatch, patchPath, addAndUploadPatchWithFileOps } = useAddPatch(path); + const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( null, ); @@ -319,6 +325,38 @@ export function ImageField({ path }: { path: SourcePath }) { )}
)} + {schemaAtPath.data.moduleMetadata && + Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( + > + > + } + selectedRef={source?._ref ?? null} + onSelect={(entry: GalleryEntry) => { + addPatch( + [ + { + op: "replace", + path: patchPath, + value: { + [FILE_REF_PROP]: entry.filePath, + [VAL_EXTENSION]: "file", + [FILE_REF_SUBTYPE_TAG]: "image", + metadata: entry.metadata, + }, + }, + ], + "image", + ); + }} + isImage + disabled={disabled} + portalContainer={portalContainer} + /> + )} From e7f9586ece7cfeb4004e087bad742e7cf507e5ac Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 23 Feb 2026 18:00:36 +0000 Subject: [PATCH 10/32] Fix example --- examples/next/app/external.val.ts | 1 + examples/next/content/authors.val.ts | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/examples/next/app/external.val.ts b/examples/next/app/external.val.ts index b5b116057..5798226c1 100644 --- a/examples/next/app/external.val.ts +++ b/examples/next/app/external.val.ts @@ -11,5 +11,6 @@ export default c.define( "https://www.instagram.com": { title: "Instagram" }, "https://www.linkedin.com": { title: "LinkedIn" }, "https://www.github.com": { title: "GitHub" }, + "https://val.build": { title: "" }, }, ); diff --git a/examples/next/content/authors.val.ts b/examples/next/content/authors.val.ts index 63d9d7bd9..46807fd7e 100644 --- a/examples/next/content/authors.val.ts +++ b/examples/next/content/authors.val.ts @@ -22,7 +22,7 @@ export default c.define("/content/authors.val.ts", schema, { teddy: { name: "Theodor René Carlsen", birthdate: null, - image: c.image("/public/val/images/logo.png"), + image: null, }, freekh: { name: "Fredrik Ekholdt", From eb832ddf74592c2b98df301bd41101d58d1f4b7c Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 23 Feb 2026 21:07:12 +0000 Subject: [PATCH 11/32] Refactor s.files and s.images to use RecordSchema --- packages/core/src/schema/deserialize.ts | 33 +- packages/core/src/schema/files.test.ts | 3 +- packages/core/src/schema/files.ts | 423 +-------------- packages/core/src/schema/images.test.ts | 3 +- packages/core/src/schema/images.ts | 504 ++---------------- packages/core/src/schema/index.ts | 6 +- packages/core/src/schema/record.ts | 264 ++++++++- .../src/internal/zod/SerializedSchema.ts | 24 +- 8 files changed, 365 insertions(+), 895 deletions(-) diff --git a/packages/core/src/schema/deserialize.ts b/packages/core/src/schema/deserialize.ts index 44f1deebc..fc6a973ae 100644 --- a/packages/core/src/schema/deserialize.ts +++ b/packages/core/src/schema/deserialize.ts @@ -7,9 +7,7 @@ import { ArraySchema } from "./array"; import { BooleanSchema } from "./boolean"; import { DateSchema } from "./date"; import { FileSchema } from "./file"; -import { FilesSchema } from "./files"; import { ImageMetadata, ImageSchema } from "./image"; -import { ImagesSchema } from "./images"; import { KeyOfSchema } from "./keyOf"; import { LiteralSchema } from "./literal"; import { NumberSchema } from "./number"; @@ -108,6 +106,17 @@ export function deserializeSchema( serialized.key ? (deserializeSchema(serialized.key) as Schema) : null, + serialized.mediaType + ? { + type: serialized.mediaType, + accept: serialized.accept ?? "*/*", + directory: serialized.directory ?? "/public/val", + remote: serialized.remote ?? false, + altSchema: serialized.alt + ? deserializeSchema(serialized.alt) + : undefined, + } + : undefined, ); case "keyOf": return new KeyOfSchema( @@ -136,28 +145,8 @@ export function deserializeSchema( } case "file": return new FileSchema(serialized.options, serialized.opt); - case "files": - return new FilesSchema( - { - accept: serialized.accept, - directory: serialized.directory as "/public" | `/public/${string}`, - }, - serialized.opt, - serialized.remote, - ); case "image": return new ImageSchema(serialized.options, serialized.opt); - case "images": - return new ImagesSchema( - { - accept: serialized.accept as `image/${string}`, - directory: serialized.directory as "/public" | `/public/${string}`, - // Note: alt schema deserialization would need the alt schema to be deserialized - // For now we use the default alt schema - }, - serialized.opt, - serialized.remote, - ); case "date": return new DateSchema(serialized.options); default: { diff --git a/packages/core/src/schema/files.test.ts b/packages/core/src/schema/files.test.ts index a6a3b541d..2019fb026 100644 --- a/packages/core/src/schema/files.test.ts +++ b/packages/core/src/schema/files.test.ts @@ -191,7 +191,8 @@ describe("FilesSchema", () => { test("should serialize with correct type", () => { const schema = files({ accept: "application/pdf" }); const serialized = schema["executeSerialize"](); - expect(serialized.type).toBe("files"); + expect(serialized.type).toBe("record"); + expect((serialized as any).mediaType).toBe("files"); expect(serialized.accept).toBe("application/pdf"); expect(serialized.directory).toBe("/public/val"); expect(serialized.opt).toBe(false); diff --git a/packages/core/src/schema/files.ts b/packages/core/src/schema/files.ts index c7da42761..ef645ac76 100644 --- a/packages/core/src/schema/files.ts +++ b/packages/core/src/schema/files.ts @@ -1,15 +1,8 @@ -import { CustomValidateFunction, Schema, SchemaAssertResult } from "."; -import { ReifiedRender, RenderSelector } from "../render"; -import { splitRemoteRef } from "../remote/splitRemoteRef"; -import { createValPathOfItem } from "../selector/SelectorProxy"; -import { ModuleFilePath, SourcePath } from "../val"; -import { - ValidationError, - ValidationErrors, -} from "./validation/ValidationError"; -import { ImageSource } from "../source/image"; -import { RemoteSource } from "../source/remote"; -import { ImageMetadata } from "./image"; +import { Schema } from "."; +import type { SerializedRecordSchema } from "./record"; +import { RecordSchema } from "./record"; +import { ObjectSchema } from "./object"; +import { StringSchema } from "./string"; /** * Options for s.files() @@ -39,392 +32,10 @@ export type FilesEntryMetadata = { mimeType: string; }; -export type SerializedFilesSchema = { - type: "files"; - accept: string; - directory: string; - opt: boolean; - remote: boolean; - customValidate?: boolean; -}; - -export class FilesSchema< - Src extends Record | null, -> extends Schema { - private readonly directory: "/public" | `/public/${string}`; - - constructor( - private readonly options: FilesOptions, - private readonly opt: boolean = false, - private readonly isRemote: boolean = false, - private readonly customValidateFunctions: CustomValidateFunction[] = [], - ) { - super(); - this.directory = options.directory ?? "/public/val"; - } - - remote(): FilesSchema { - return new FilesSchema( - this.options, - this.opt, - true, - this.customValidateFunctions, - ); - } - - validate(validationFunction: CustomValidateFunction): FilesSchema { - return new FilesSchema(this.options, this.opt, this.isRemote, [ - ...this.customValidateFunctions, - validationFunction, - ]); - } - - protected executeValidate(path: SourcePath, src: Src): ValidationErrors { - let error: ValidationErrors = false; - const customValidationErrors: ValidationError[] = - this.executeCustomValidateFunctions(src, this.customValidateFunctions, { - path, - }); - - if (this.opt && (src === null || src === undefined)) { - return customValidationErrors.length > 0 - ? { [path]: customValidationErrors } - : false; - } - - if (src === null || src === undefined) { - return { - [path]: [ - ...customValidationErrors, - { message: `Non-optional files was null or undefined.`, value: src }, - ], - } as ValidationErrors; - } - - if (typeof src !== "object") { - return { - [path]: [ - ...customValidationErrors, - { message: `Expected 'object', got '${typeof src}'`, value: src }, - ], - } as ValidationErrors; - } - - if (Array.isArray(src)) { - return { - [path]: [ - ...customValidationErrors, - { message: `Expected 'object', got 'array'`, value: src }, - ], - } as ValidationErrors; - } - - for (const customValidationError of customValidationErrors) { - error = this.appendValidationError( - error, - path, - customValidationError.message, - src, - customValidationError.schemaError, - ); - } - - // Validate each entry - for (const [key, entry] of Object.entries(src)) { - const subPath = createValPathOfItem(path, key); - if (!subPath) { - error = this.appendValidationError( - error, - path, - `Internal error: could not create path at ${path} for key ${key}`, - src, - ); - continue; - } - - // Validate key is either a valid local path or remote URL - const keyError = this.validateKey(subPath, key); - if (keyError) { - if (error) { - error = { ...error, ...keyError }; - } else { - error = keyError; - } - } - - // Validate entry metadata - const entryError = this.validateEntry( - subPath, - entry as FilesEntryMetadata, - ); - if (entryError) { - if (error) { - error = { ...error, ...entryError }; - } else { - error = entryError; - } - } - } - - return error; - } - - private isRemoteUrl(url: string): boolean { - return url.startsWith("https://") || url.startsWith("http://"); - } - - private validateKey(path: SourcePath, key: string): ValidationErrors { - const isRemoteUrl = this.isRemoteUrl(key); - const isLocalPath = key.startsWith(this.directory); - - if (this.isRemote) { - // When remote is enabled, accept either remote URLs or local paths - if (isRemoteUrl) { - // Validate remote URL format using splitRemoteRef - const remoteResult = splitRemoteRef(key); - if (remoteResult.status === "error") { - return { - [path]: [ - { - message: `Invalid remote URL format. Use Val tooling (CLI, VS Code extension, or Val Studio) to upload files. Got: ${key}`, - value: key, - fixes: ["files:check-remote"], - }, - ], - }; - } - // Check that the file path in the remote URL matches our directory constraint - const remotePath = "/" + remoteResult.filePath; - if (!remotePath.startsWith(this.directory)) { - return { - [path]: [ - { - message: `Remote file path '${remotePath}' is not in expected directory '${this.directory}'. Use Val tooling to upload files to the correct directory.`, - value: key, - fixes: ["files:check-remote"], - }, - ], - }; - } - return false; - } - if (!isLocalPath) { - return { - [path]: [ - { - message: `Expected a remote URL (https://...) or a local path starting with ${this.directory}/. Got: ${key}`, - value: key, - }, - ], - }; - } - } else { - // When remote is disabled, only accept local paths - if (isRemoteUrl) { - return { - [path]: [ - { - message: `Remote URLs are not allowed. Use .remote() to enable remote files. Got: ${key}`, - value: key, - fixes: ["files:check-remote"], - }, - ], - }; - } - if (!isLocalPath) { - return { - [path]: [ - { - message: `File path must be within the ${this.directory}/ directory. Got: ${key}`, - value: key, - }, - ], - }; - } - } - - return false; - } - - private validateEntry( - path: SourcePath, - entry: FilesEntryMetadata, - ): ValidationErrors { - if (typeof entry !== "object" || entry === null) { - return { - [path]: [ - { message: `Expected 'object', got '${typeof entry}'`, value: entry }, - ], - }; - } - - const errors: ValidationError[] = []; - - // Validate mimeType - if (typeof entry.mimeType !== "string") { - errors.push({ - message: `Expected 'mimeType' to be a string, got '${typeof entry.mimeType}'`, - value: entry, - }); - } else { - // Validate against accept pattern - const mimeTypeError = this.validateMimeType(entry.mimeType); - if (mimeTypeError) { - errors.push({ message: mimeTypeError, value: entry }); - } - } - - if (errors.length > 0) { - return { [path]: errors }; - } - - return false; - } - - private validateMimeType(mimeType: string): string | null { - const { accept } = this.options; - - if (!mimeType.includes("/")) { - return `Invalid mime type format. Got: '${mimeType}'`; - } - - const acceptedTypes = accept.split(",").map((type) => type.trim()); - - const isValidMimeType = acceptedTypes.some((acceptedType) => { - if (acceptedType === "*/*") { - return true; - } - if (acceptedType.endsWith("/*")) { - const baseType = acceptedType.slice(0, -2); - return mimeType.startsWith(baseType); - } - return acceptedType === mimeType; - }); - - if (!isValidMimeType) { - return `Mime type mismatch. Found '${mimeType}' but schema accepts '${accept}'`; - } - - return null; - } - - protected executeAssert( - path: SourcePath, - src: unknown, - ): SchemaAssertResult { - if (this.opt && src === null) { - return { - success: true, - data: src, - } as SchemaAssertResult; - } - - if (src === null) { - return { - success: false, - errors: { - [path]: [ - { message: `Expected 'object', got 'null'`, typeError: true }, - ], - }, - }; - } - - if (typeof src !== "object") { - return { - success: false, - errors: { - [path]: [ - { - message: `Expected 'object', got '${typeof src}'`, - typeError: true, - }, - ], - }, - }; - } - - if (Array.isArray(src)) { - return { - success: false, - errors: { - [path]: [ - { message: `Expected 'object', got 'array'`, typeError: true }, - ], - }, - }; - } - - return { - success: true, - data: src, - } as SchemaAssertResult; - } - - nullable(): FilesSchema { - return new FilesSchema( - this.options, - true, - this.isRemote, - this.customValidateFunctions as CustomValidateFunction[], - ); - } - - protected executeSerialize(): SerializedFilesSchema { - return { - type: "files", - accept: this.options.accept, - directory: this.directory, - opt: this.opt, - remote: this.isRemote, - customValidate: - this.customValidateFunctions && - this.customValidateFunctions?.length > 0, - }; - } - - private renderInput: { - layout: "list"; - select: (input: { - key: string; - val: RenderSelector>; - }) => { - title: string; - subtitle?: string | null; - image?: ImageSource | RemoteSource | null; - }; - } | null = null; - - protected executeRender( - sourcePath: SourcePath | ModuleFilePath, - src: Src, - ): ReifiedRender { - const res: ReifiedRender = {}; - if (src === null) { - return res; - } - // Files don't have nested render logic, so we just return empty - return res; - } +export type SerializedFilesSchema = SerializedRecordSchema; - render(input: { - as: "list"; - select: (input: { - key: string; - val: RenderSelector>; - }) => { - title: string; - subtitle?: string | null; - image?: ImageSource | RemoteSource | null; - }; - }) { - this.renderInput = { - layout: input.as, - select: input.select, - }; - return this; - } -} +type FilesItemProps = { mimeType: StringSchema }; +type FilesItemSrc = { mimeType: string }; /** * Define a collection of files. @@ -444,6 +55,20 @@ export class FilesSchema< */ export const files = ( options: FilesOptions, -): FilesSchema> => { - return new FilesSchema(options); +): RecordSchema< + ObjectSchema, + Schema, + Record +> => { + const directory = options.directory ?? "/public/val"; + const itemSchema = new ObjectSchema( + { mimeType: new StringSchema({}, false) }, + false, + ); + return new RecordSchema(itemSchema, false, [], null, null, { + type: "files", + accept: options.accept, + directory, + remote: options.remote ?? false, + }); }; diff --git a/packages/core/src/schema/images.test.ts b/packages/core/src/schema/images.test.ts index 4d4679eeb..a3413a90e 100644 --- a/packages/core/src/schema/images.test.ts +++ b/packages/core/src/schema/images.test.ts @@ -231,7 +231,8 @@ describe("ImagesSchema", () => { test("should serialize with correct type", () => { const schema = images({ accept: "image/webp" }); const serialized = schema["executeSerialize"](); - expect(serialized.type).toBe("images"); + expect(serialized.type).toBe("record"); + expect((serialized as any).mediaType).toBe("images"); expect(serialized.accept).toBe("image/webp"); expect(serialized.directory).toBe("/public/val"); expect(serialized.opt).toBe(false); diff --git a/packages/core/src/schema/images.ts b/packages/core/src/schema/images.ts index 29513f9b2..3f62268eb 100644 --- a/packages/core/src/schema/images.ts +++ b/packages/core/src/schema/images.ts @@ -1,23 +1,10 @@ -import { - CustomValidateFunction, - Schema, - SchemaAssertResult, - SerializedSchema, -} from "."; -import { ReifiedRender, RenderSelector } from "../render"; -import { splitRemoteRef } from "../remote/splitRemoteRef"; -import { SelectorSource } from "../selector"; -import { createValPathOfItem } from "../selector/SelectorProxy"; -import { ModuleFilePath, SourcePath } from "../val"; -import { - ValidationError, - ValidationErrors, -} from "./validation/ValidationError"; -import { StringSchema, string } from "./string"; +import { Schema } from "."; +import type { SerializedRecordSchema } from "./record"; import { RecordSchema } from "./record"; -import { ImageSource } from "../source/image"; -import { RemoteSource } from "../source/remote"; -import { ImageMetadata } from "./image"; +import { ObjectSchema } from "./object"; +import { StringSchema, string } from "./string"; +import { NumberSchema } from "./number"; +import { SelectorSource } from "../selector"; /** * Alt schema type - can be a string, nullable string, or a record of locale to string @@ -69,447 +56,21 @@ export type ImagesEntryMetadata = { }; }; -export type SerializedImagesSchema = { - type: "images"; - accept: string; - directory: string; - alt: SerializedSchema; - opt: boolean; - remote: boolean; - customValidate?: boolean; -}; - -export class ImagesSchema< - Accept extends `image/${string}`, - Src extends Record | null, -> extends Schema { - private readonly directory: "/public" | `/public/${string}`; - private readonly altSchema: AltSchema; - - constructor( - private readonly options: ImagesOptions, - private readonly opt: boolean = false, - private readonly isRemote: boolean = false, - private readonly customValidateFunctions: CustomValidateFunction[] = [], - ) { - super(); - this.directory = options.directory ?? "/public/val"; - this.altSchema = options.alt ?? string().nullable(); - } - - remote(): ImagesSchema { - return new ImagesSchema( - this.options, - this.opt, - true, - this.customValidateFunctions, - ); - } - - validate( - validationFunction: CustomValidateFunction, - ): ImagesSchema { - return new ImagesSchema(this.options, this.opt, this.isRemote, [ - ...this.customValidateFunctions, - validationFunction, - ]); - } - - protected executeValidate(path: SourcePath, src: Src): ValidationErrors { - let error: ValidationErrors = false; - const customValidationErrors: ValidationError[] = - this.executeCustomValidateFunctions(src, this.customValidateFunctions, { - path, - }); - - if (this.opt && (src === null || src === undefined)) { - return customValidationErrors.length > 0 - ? { [path]: customValidationErrors } - : false; - } - - if (src === null || src === undefined) { - return { - [path]: [ - ...customValidationErrors, - { message: `Non-optional images was null or undefined.`, value: src }, - ], - } as ValidationErrors; - } - - if (typeof src !== "object") { - return { - [path]: [ - ...customValidationErrors, - { message: `Expected 'object', got '${typeof src}'`, value: src }, - ], - } as ValidationErrors; - } - - if (Array.isArray(src)) { - return { - [path]: [ - ...customValidationErrors, - { message: `Expected 'object', got 'array'`, value: src }, - ], - } as ValidationErrors; - } - - for (const customValidationError of customValidationErrors) { - error = this.appendValidationError( - error, - path, - customValidationError.message, - src, - customValidationError.schemaError, - ); - } - - // Validate each entry - for (const [key, entry] of Object.entries(src)) { - const subPath = createValPathOfItem(path, key); - if (!subPath) { - error = this.appendValidationError( - error, - path, - `Internal error: could not create path at ${path} for key ${key}`, - src, - ); - continue; - } - - // Validate key is either a valid local path or remote URL - const keyError = this.validateKey(subPath, key); - if (keyError) { - if (error) { - error = { ...error, ...keyError }; - } else { - error = keyError; - } - } - - // Validate entry metadata - const entryError = this.validateEntry( - subPath, - entry as ImagesEntryMetadata, - ); - if (entryError) { - if (error) { - error = { ...error, ...entryError }; - } else { - error = entryError; - } - } - } - - return error; - } - - private isRemoteUrl(url: string): boolean { - return url.startsWith("https://") || url.startsWith("http://"); - } - - private validateKey(path: SourcePath, key: string): ValidationErrors { - const isRemoteUrl = this.isRemoteUrl(key); - const isLocalPath = key.startsWith(this.directory); - - if (this.isRemote) { - // When remote is enabled, accept either remote URLs or local paths - if (isRemoteUrl) { - // Validate remote URL format using splitRemoteRef - const remoteResult = splitRemoteRef(key); - if (remoteResult.status === "error") { - return { - [path]: [ - { - message: `Invalid remote URL format. Use Val tooling (CLI, VS Code extension, or Val Studio) to upload images. Got: ${key}`, - value: key, - fixes: ["images:check-remote"], - }, - ], - }; - } - // Check that the file path in the remote URL matches our directory constraint - const remotePath = "/" + remoteResult.filePath; - if (!remotePath.startsWith(this.directory)) { - return { - [path]: [ - { - message: `Remote file path '${remotePath}' is not in expected directory '${this.directory}'. Use Val tooling to upload images to the correct directory.`, - value: key, - fixes: ["images:check-remote"], - }, - ], - }; - } - return false; - } - if (!isLocalPath) { - return { - [path]: [ - { - message: `Expected a remote URL (https://...) or a local path starting with ${this.directory}/. Got: ${key}`, - value: key, - }, - ], - }; - } - } else { - // When remote is disabled, only accept local paths - if (isRemoteUrl) { - return { - [path]: [ - { - message: `Remote URLs are not allowed. Use .remote() to enable remote images. Got: ${key}`, - value: key, - fixes: ["images:check-remote"], - }, - ], - }; - } - if (!isLocalPath) { - return { - [path]: [ - { - message: `File path must be within the ${this.directory}/ directory. Got: ${key}`, - value: key, - }, - ], - }; - } - } - - return false; - } - - private validateEntry( - path: SourcePath, - entry: ImagesEntryMetadata, - ): ValidationErrors { - if (typeof entry !== "object" || entry === null) { - return { - [path]: [ - { message: `Expected 'object', got '${typeof entry}'`, value: entry }, - ], - }; - } - - const errors: ValidationError[] = []; - - // Validate width - if (typeof entry.width !== "number" || entry.width <= 0) { - errors.push({ - message: `Expected 'width' to be a positive number, got '${entry.width}'`, - value: entry, - }); - } - - // Validate height - if (typeof entry.height !== "number" || entry.height <= 0) { - errors.push({ - message: `Expected 'height' to be a positive number, got '${entry.height}'`, - value: entry, - }); - } +export type SerializedImagesSchema = SerializedRecordSchema; - // Validate mimeType - if (typeof entry.mimeType !== "string") { - errors.push({ - message: `Expected 'mimeType' to be a string, got '${typeof entry.mimeType}'`, - value: entry, - }); - } else { - // Validate against accept pattern - const mimeTypeError = this.validateMimeType(entry.mimeType); - if (mimeTypeError) { - errors.push({ message: mimeTypeError, value: entry }); - } - } - - // Validate hotspot if present - if (entry.hotspot !== undefined) { - if ( - typeof entry.hotspot !== "object" || - typeof entry.hotspot.x !== "number" || - typeof entry.hotspot.y !== "number" - ) { - errors.push({ - message: `Hotspot must be an object with x and y as numbers.`, - value: entry, - }); - } - } - - // Validate alt using the alt schema - const altPath = createValPathOfItem(path, "alt"); - if (altPath) { - // Cast to Schema to access protected method - const altSchemaAsSchema = this - .altSchema as unknown as Schema; - const altError = altSchemaAsSchema["executeValidate"]( - altPath, - entry.alt as SelectorSource, - ); - if (altError) { - return altError; - } - } - - if (errors.length > 0) { - return { [path]: errors }; - } - - return false; - } - - private validateMimeType(mimeType: string): string | null { - const { accept } = this.options; - - if (!mimeType.includes("/")) { - return `Invalid mime type format. Got: '${mimeType}'`; - } - - const acceptedTypes = accept.split(",").map((type) => type.trim()); - - const isValidMimeType = acceptedTypes.some((acceptedType) => { - if (acceptedType === "image/*") { - return mimeType.startsWith("image/"); - } - if (acceptedType.endsWith("/*")) { - const baseType = acceptedType.slice(0, -2); - return mimeType.startsWith(baseType); - } - return acceptedType === mimeType; - }); - - if (!isValidMimeType) { - return `Mime type mismatch. Found '${mimeType}' but schema accepts '${accept}'`; - } - - return null; - } - - protected executeAssert( - path: SourcePath, - src: unknown, - ): SchemaAssertResult { - if (this.opt && src === null) { - return { - success: true, - data: src, - } as SchemaAssertResult; - } - - if (src === null) { - return { - success: false, - errors: { - [path]: [ - { message: `Expected 'object', got 'null'`, typeError: true }, - ], - }, - }; - } - - if (typeof src !== "object") { - return { - success: false, - errors: { - [path]: [ - { - message: `Expected 'object', got '${typeof src}'`, - typeError: true, - }, - ], - }, - }; - } - - if (Array.isArray(src)) { - return { - success: false, - errors: { - [path]: [ - { message: `Expected 'object', got 'array'`, typeError: true }, - ], - }, - }; - } - - return { - success: true, - data: src, - } as SchemaAssertResult; - } - - nullable(): ImagesSchema { - return new ImagesSchema( - this.options, - true, - this.isRemote, - this.customValidateFunctions as CustomValidateFunction[], - ); - } - - protected executeSerialize(): SerializedImagesSchema { - // Cast to Schema to access protected method - const altSchemaAsSchema = this - .altSchema as unknown as Schema; - return { - type: "images", - accept: this.options.accept, - directory: this.directory, - alt: altSchemaAsSchema["executeSerialize"](), - opt: this.opt, - remote: this.isRemote, - customValidate: - this.customValidateFunctions && - this.customValidateFunctions?.length > 0, - }; - } - - private renderInput: { - layout: "list"; - select: (input: { - key: string; - val: RenderSelector>; - }) => { - title: string; - subtitle?: string | null; - image?: ImageSource | RemoteSource | null; - }; - } | null = null; - - protected executeRender( - sourcePath: SourcePath | ModuleFilePath, - src: Src, - ): ReifiedRender { - const res: ReifiedRender = {}; - if (src === null) { - return res; - } - // Images don't have nested render logic, so we just return empty - return res; - } - - render(input: { - as: "list"; - select: (input: { - key: string; - val: RenderSelector>; - }) => { - title: string; - subtitle?: string | null; - image?: ImageSource | RemoteSource | null; - }; - }) { - this.renderInput = { - layout: input.as, - select: input.select, - }; - return this; - } -} +// Item schema types for images (alt simplified to string | null for typing) +type ImagesItemProps = { + width: NumberSchema; + height: NumberSchema; + mimeType: StringSchema; + alt: StringSchema; +}; +type ImagesItemSrc = { + width: number; + height: number; + mimeType: string; + alt: string | null; +}; /** * Define a collection of images. @@ -533,6 +94,27 @@ export class ImagesSchema< */ export const images = ( options: ImagesOptions, -): ImagesSchema> => { - return new ImagesSchema(options); +): RecordSchema< + ObjectSchema, + Schema, + Record +> => { + const directory = options.directory ?? "/public/val"; + const altSchema = options.alt ?? string().nullable(); + const itemSchema = new ObjectSchema( + { + width: new NumberSchema(undefined, false), + height: new NumberSchema(undefined, false), + mimeType: new StringSchema({}, false), + alt: new StringSchema({}, true), + }, + false, + ); + return new RecordSchema(itemSchema, false, [], null, null, { + type: "images", + accept: options.accept, + directory, + remote: options.remote ?? false, + altSchema: altSchema as Schema, + }); }; diff --git a/packages/core/src/schema/index.ts b/packages/core/src/schema/index.ts index cb07c6d67..4443d7a72 100644 --- a/packages/core/src/schema/index.ts +++ b/packages/core/src/schema/index.ts @@ -4,9 +4,7 @@ import { ModuleFilePath, SourcePath } from "../val"; import { SerializedArraySchema } from "./array"; import { SerializedBooleanSchema } from "./boolean"; import { SerializedFileSchema } from "./file"; -import { SerializedFilesSchema } from "./files"; import { SerializedImageSchema } from "./image"; -import { SerializedImagesSchema } from "./images"; import { SerializedKeyOfSchema } from "./keyOf"; import { SerializedLiteralSchema } from "./literal"; import { SerializedNumberSchema } from "./number"; @@ -41,11 +39,9 @@ export type SerializedSchema = | SerializedRecordSchema | SerializedKeyOfSchema | SerializedFileSchema - | SerializedFilesSchema | SerializedDateSchema | SerializedRouteSchema - | SerializedImageSchema - | SerializedImagesSchema; + | SerializedImageSchema; type Primitives = number | string | boolean | null | FileSource; export type AssertError = diff --git a/packages/core/src/schema/record.ts b/packages/core/src/schema/record.ts index 884fb24c6..f3c50f96f 100644 --- a/packages/core/src/schema/record.ts +++ b/packages/core/src/schema/record.ts @@ -21,6 +21,15 @@ import { ValidationError, ValidationErrors, } from "./validation/ValidationError"; +import { splitRemoteRef } from "../remote/splitRemoteRef"; + +type MediaOptions = { + type: "files" | "images"; + accept: string; + directory: string; + remote: boolean; + altSchema?: Schema; +}; export type SerializedRecordSchema = { type: "record"; @@ -29,6 +38,12 @@ export type SerializedRecordSchema = { opt: boolean; router?: string; customValidate?: boolean; + // Optional media collection marker for files/images that are backed by a record + mediaType?: "files" | "images"; + accept?: string; + directory?: string; + remote?: boolean; + alt?: SerializedSchema; }; export class RecordSchema< @@ -42,6 +57,7 @@ export class RecordSchema< private readonly customValidateFunctions: CustomValidateFunction[] = [], private readonly currentRouter: ValRouter | null = null, private readonly keySchema: Schema | null = null, + private readonly mediaOptions?: MediaOptions, ) { super(); } @@ -55,6 +71,7 @@ export class RecordSchema< [...this.customValidateFunctions, validationFunction], this.currentRouter, this.keySchema, + this.mediaOptions, ); } @@ -144,6 +161,16 @@ export class RecordSchema< } at key ${elem}`, // Should! never happen src, ); + } else if (this.mediaOptions) { + // Media collection: validate key (path/URL) and entry (metadata) + const keyErr = this.validateMediaKey(subPath, key); + if (keyErr) { + error = error ? { ...error, ...keyErr } : keyErr; + } + const entryErr = this.validateMediaEntry(subPath, elem); + if (entryErr) { + error = error ? { ...error, ...entryErr } : entryErr; + } } else { const subError = this.item["executeValidate"]( subPath, @@ -162,6 +189,208 @@ export class RecordSchema< return error; } + private isRemoteUrl(url: string): boolean { + return url.startsWith("https://") || url.startsWith("http://"); + } + + private validateMediaKey(path: SourcePath, key: string): ValidationErrors { + if (!this.mediaOptions) { + return false; + } + const { directory, remote: isRemote, type } = this.mediaOptions; + const mediaLabel = type === "images" ? "images" : "files"; + const checkRemoteFix = + type === "images" ? "images:check-remote" : "files:check-remote"; + + const isRemoteUrl = this.isRemoteUrl(key); + const isLocalPath = key.startsWith(directory); + + if (isRemote) { + // When remote is enabled, accept either remote URLs or local paths + if (isRemoteUrl) { + // Validate remote URL format using splitRemoteRef + const remoteResult = splitRemoteRef(key); + if (remoteResult.status === "error") { + return { + [path]: [ + { + message: `Invalid remote URL format. Use Val tooling (CLI, VS Code extension, or Val Studio) to upload ${mediaLabel}. Got: ${key}`, + value: key, + fixes: [checkRemoteFix], + }, + ], + }; + } + // Check that the file path in the remote URL matches our directory constraint + const remotePath = "/" + remoteResult.filePath; + if (!remotePath.startsWith(directory)) { + return { + [path]: [ + { + message: `Remote file path '${remotePath}' is not in expected directory '${directory}'. Use Val tooling to upload ${mediaLabel} to the correct directory.`, + value: key, + fixes: [checkRemoteFix], + }, + ], + }; + } + return false; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `Expected a remote URL (https://...) or a local path starting with ${directory}/. Got: ${key}`, + value: key, + }, + ], + }; + } + } else { + // When remote is disabled, only accept local paths + if (isRemoteUrl) { + return { + [path]: [ + { + message: `Remote URLs are not allowed. Use .remote() to enable remote ${mediaLabel}. Got: ${key}`, + value: key, + fixes: [checkRemoteFix], + }, + ], + }; + } + if (!isLocalPath) { + return { + [path]: [ + { + message: `File path must be within the ${directory}/ directory. Got: ${key}`, + value: key, + }, + ], + }; + } + } + + return false; + } + + private validateMediaEntry( + path: SourcePath, + entry: unknown, + ): ValidationErrors { + if (!this.mediaOptions) { + return false; + } + const { type, accept, altSchema } = this.mediaOptions; + + if (typeof entry !== "object" || entry === null) { + return { + [path]: [ + { message: `Expected 'object', got '${typeof entry}'`, value: entry }, + ], + }; + } + + const entryObj = entry as Record; + const errors: ValidationError[] = []; + + if (type === "images") { + // Validate width + if (typeof entryObj.width !== "number" || entryObj.width <= 0) { + errors.push({ + message: `Expected 'width' to be a positive number, got '${entryObj.width}'`, + value: entry, + }); + } + + // Validate height + if (typeof entryObj.height !== "number" || entryObj.height <= 0) { + errors.push({ + message: `Expected 'height' to be a positive number, got '${entryObj.height}'`, + value: entry, + }); + } + } + + // Validate mimeType + if (typeof entryObj.mimeType !== "string") { + errors.push({ + message: `Expected 'mimeType' to be a string, got '${typeof entryObj.mimeType}'`, + value: entry, + }); + } else { + const mimeTypeError = this.validateMediaMimeType(entryObj.mimeType, accept); + if (mimeTypeError) { + errors.push({ message: mimeTypeError, value: entry }); + } + } + + if (type === "images") { + // Validate hotspot if present + if (entryObj.hotspot !== undefined) { + const hs = entryObj.hotspot as Record; + if ( + typeof entryObj.hotspot !== "object" || + typeof hs.x !== "number" || + typeof hs.y !== "number" + ) { + errors.push({ + message: `Hotspot must be an object with x and y as numbers.`, + value: entry, + }); + } + } + + // Validate alt using the alt schema + const altPath = createValPathOfItem(path, "alt"); + if (altPath && altSchema) { + const altError = altSchema["executeValidate"]( + altPath, + entryObj.alt as SelectorSource, + ); + if (altError) { + return errors.length > 0 + ? { ...altError, [path]: errors } + : altError; + } + } + } + + if (errors.length > 0) { + return { [path]: errors }; + } + + return false; + } + + private validateMediaMimeType(mimeType: string, accept: string): string | null { + if (!mimeType.includes("/")) { + return `Invalid mime type format. Got: '${mimeType}'`; + } + + const acceptedTypes = accept.split(",").map((type) => type.trim()); + + const isValidMimeType = acceptedTypes.some((acceptedType) => { + if (acceptedType === "*/*") { + return true; + } + if (acceptedType === "image/*") { + return mimeType.startsWith("image/"); + } + if (acceptedType.endsWith("/*")) { + const baseType = acceptedType.slice(0, -2); + return mimeType.startsWith(baseType); + } + return acceptedType === mimeType; + }); + + if (!isValidMimeType) { + return `Mime type mismatch. Found '${mimeType}' but schema accepts '${accept}'`; + } + + return null; + } + protected executeAssert( path: SourcePath, src: unknown, @@ -172,6 +401,16 @@ export class RecordSchema< data: src, } as SchemaAssertResult; } + if (src === null) { + return { + success: false, + errors: { + [path]: [ + { message: `Expected 'object', got 'null'`, typeError: true }, + ], + }, + }; + } if (typeof src !== "object") { return { success: false, @@ -208,6 +447,7 @@ export class RecordSchema< this.customValidateFunctions, this.currentRouter, this.keySchema, + this.mediaOptions, ) as RecordSchema; } @@ -218,6 +458,18 @@ export class RecordSchema< this.customValidateFunctions, router, this.keySchema, + this.mediaOptions, + ); + } + + remote(): RecordSchema { + return new RecordSchema( + this.item, + this.opt, + this.customValidateFunctions, + this.currentRouter, + this.keySchema, + this.mediaOptions ? { ...this.mediaOptions, remote: true } : undefined, ); } @@ -284,7 +536,7 @@ export class RecordSchema< } protected executeSerialize(): SerializedRecordSchema { - return { + const result: SerializedRecordSchema = { type: "record", item: this.item["executeSerialize"](), key: this.keySchema?.["executeSerialize"](), @@ -294,6 +546,16 @@ export class RecordSchema< this.customValidateFunctions && this.customValidateFunctions?.length > 0, }; + if (this.mediaOptions) { + result.mediaType = this.mediaOptions.type; + result.accept = this.mediaOptions.accept; + result.directory = this.mediaOptions.directory; + result.remote = this.mediaOptions.remote; + if (this.mediaOptions.altSchema) { + result.alt = this.mediaOptions.altSchema["executeSerialize"](); + } + } + return result; } private renderInput: { diff --git a/packages/shared/src/internal/zod/SerializedSchema.ts b/packages/shared/src/internal/zod/SerializedSchema.ts index 7bcd8fd25..1850aa778 100644 --- a/packages/shared/src/internal/zod/SerializedSchema.ts +++ b/packages/shared/src/internal/zod/SerializedSchema.ts @@ -157,11 +157,25 @@ export const SerializedRichTextSchema: z.ZodType = export const SerializedRecordSchema: z.ZodType = z.lazy(() => { - return z.object({ - type: z.literal("record"), - item: SerializedSchema, - opt: z.boolean(), - }); + return z + .object({ + type: z.literal("record"), + item: SerializedSchema, + opt: z.boolean(), + // Optional gallery marker for files/images + mediaType: z + .union([z.literal("files"), z.literal("images")]) + .optional(), + // Optional legacy gallery metadata + accept: z.string().optional(), + directory: z.string().optional(), + remote: z.boolean().optional(), + alt: SerializedSchema.optional(), + moduleMetadata: z + .record(z.string(), z.record(z.string(), z.any())) + .optional(), + }) + .passthrough(); }); export const SerializedKeyOfSchema: z.ZodType = z.lazy( From be22916cb77bccbe1203aba2cc4826da78a27ee1 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 23 Feb 2026 22:12:05 +0000 Subject: [PATCH 12/32] Align types after refactor of Internal.getSource --- packages/core/src/module.ts | 4 +-- .../spa/components/Search/stories/mockData.ts | 6 ++-- packages/ui/spa/components/ValStudio.tsx | 2 +- .../ui/spa/components/fields/FileField.tsx | 4 +-- .../ui/spa/components/fields/ImageField.tsx | 3 +- packages/ui/spa/components/getKeysOf.test.ts | 15 ++++----- packages/ui/spa/components/getKeysOf.ts | 20 ++++++------ packages/ui/spa/components/getNavPath.ts | 4 +-- .../spa/components/getRouteReferences.test.ts | 15 ++++----- .../ui/spa/components/getRouteReferences.ts | 21 +++++++------ packages/ui/spa/resolvePatchPath.ts | 19 ++++++------ packages/ui/spa/search/createSearchIndex.ts | 28 +++++++++++------ packages/ui/spa/search/search.test.ts | 7 ++--- packages/ui/spa/search/search.worker.ts | 4 +-- .../ui/spa/utils/traverseSchemaSource.test.ts | 31 +++++++++---------- packages/ui/spa/utils/traverseSchemaSource.ts | 28 +++++++++++------ 16 files changed, 110 insertions(+), 101 deletions(-) diff --git a/packages/core/src/module.ts b/packages/core/src/module.ts index 84c45f3f3..67ef43ca5 100644 --- a/packages/core/src/module.ts +++ b/packages/core/src/module.ts @@ -140,9 +140,7 @@ export function enrichFileImageRemoteSourceWithMetadata< return source; } -export function getSource( - valModule: ValModule, -): T { +export function getSource(valModule: ValModule): T { return valModule[GetSource] as T; } diff --git a/packages/ui/spa/components/Search/stories/mockData.ts b/packages/ui/spa/components/Search/stories/mockData.ts index a714f6d57..00688ac33 100644 --- a/packages/ui/spa/components/Search/stories/mockData.ts +++ b/packages/ui/spa/components/Search/stories/mockData.ts @@ -3,7 +3,9 @@ import { Json, ModuleFilePath, ReifiedRender, + Source, SerializedSchema, + ValModule, initVal, } from "@valbuild/core"; @@ -464,7 +466,7 @@ function createMockData() { ); // Extract schemas and sources from the modules - const modules = [ + const modules: ValModule[] = [ blogPages, articles, settings, @@ -474,7 +476,7 @@ function createMockData() { config, ]; const schemas: Record = {}; - const sources: Record = {}; + const sources: Record = {}; const renders: Record = {}; for (const module of modules) { const moduleFilePath = Internal.getValPath(module); diff --git a/packages/ui/spa/components/ValStudio.tsx b/packages/ui/spa/components/ValStudio.tsx index 209ecc4ae..cd6144569 100644 --- a/packages/ui/spa/components/ValStudio.tsx +++ b/packages/ui/spa/components/ValStudio.tsx @@ -1,5 +1,5 @@ import { FC } from "react"; -import { ValClient } from "@valbuild/shared/src/internal/ValClient"; +import { ValClient } from "@valbuild/shared/internal"; import { ValProvider } from "./ValProvider"; import { Themes } from "./ValThemeProvider"; import { Layout } from "./Layout"; diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index 55552ca4d..e4cefa993 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -10,7 +10,7 @@ import { SerializedImageSchema, SerializedFileSchema, } from "@valbuild/core"; -import { Patch } from "@valbuild/core/patch"; +import { JSONValue, Patch } from "@valbuild/core/patch"; import { FieldLoading } from "../FieldLoading"; import { FieldNotFound } from "../FieldNotFound"; import { FieldSchemaError } from "../FieldSchemaError"; @@ -290,7 +290,7 @@ export function FileField({ path }: { path: SourcePath }) { value: { [FILE_REF_PROP]: entry.filePath, [VAL_EXTENSION]: "file", - metadata: entry.metadata, + metadata: entry.metadata as JSONValue, }, }, ], diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index b692be5d8..a6d8b71b6 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -32,6 +32,7 @@ import { Button } from "../designSystem/button"; import { useValPortal } from "../ValPortalProvider"; import { MediaPicker } from "../MediaPicker/MediaPicker"; import type { GalleryEntry } from "../MediaPicker/MediaPicker"; +import { JSONValue } from "@valbuild/core/patch"; export function ImageField({ path }: { path: SourcePath }) { const type = "image"; @@ -345,7 +346,7 @@ export function ImageField({ path }: { path: SourcePath }) { [FILE_REF_PROP]: entry.filePath, [VAL_EXTENSION]: "file", [FILE_REF_SUBTYPE_TAG]: "image", - metadata: entry.metadata, + metadata: entry.metadata as JSONValue, }, }, ], diff --git a/packages/ui/spa/components/getKeysOf.test.ts b/packages/ui/spa/components/getKeysOf.test.ts index 744953252..fe61aeb29 100644 --- a/packages/ui/spa/components/getKeysOf.test.ts +++ b/packages/ui/spa/components/getKeysOf.test.ts @@ -1,12 +1,11 @@ import { Internal, - Json, ModuleFilePath, SerializedSchema, + Source, ValModule, initVal, } from "@valbuild/core"; -import { SelectorSource } from "@valbuild/core"; import { getKeysOf } from "./getKeysOf"; const { s, c } = initVal(); @@ -205,9 +204,9 @@ describe("getKeysOf", () => { }); }); -function getTestData(valModules: ValModule[]) { +function getTestData(valModules: ValModule[]) { const schemas: Record = {}; - const sources: Record = {}; + const sources: Record = {}; for (const valModule of valModules) { const moduleFilePath = getModuleFilePath(valModule); schemas[moduleFilePath] = getSchema(valModule); @@ -216,13 +215,11 @@ function getTestData(valModules: ValModule[]) { return { schemas, sources }; } -function getModuleFilePath( - valModule: ValModule, -): ModuleFilePath { +function getModuleFilePath(valModule: ValModule): ModuleFilePath { return Internal.getValPath(valModule) as unknown as ModuleFilePath; } -function getSchema(valModule: ValModule): SerializedSchema { +function getSchema(valModule: ValModule): SerializedSchema { const schema = Internal.getSchema(valModule)?.["executeSerialize"](); if (!schema) { throw new Error("Schema not found"); @@ -230,7 +227,7 @@ function getSchema(valModule: ValModule): SerializedSchema { return schema; } -function getSource(valModule: ValModule): Json { +function getSource(valModule: ValModule): Source { const source = Internal.getSource(valModule); if (!source) { throw new Error("Source not found"); diff --git a/packages/ui/spa/components/getKeysOf.ts b/packages/ui/spa/components/getKeysOf.ts index 98333ddff..fd7128f31 100644 --- a/packages/ui/spa/components/getKeysOf.ts +++ b/packages/ui/spa/components/getKeysOf.ts @@ -2,18 +2,18 @@ import { Json, ModuleFilePath, ModuleFilePathSep, + Source, SerializedObjectSchema, SerializedSchema, SourcePath, } from "@valbuild/core"; -import { isJsonArray } from "../utils/isJsonArray"; // TODO: right now we only support keyOf MODULES that are records // We are planning to add support for keyOf selectors (i.e. nested properties of modules) that are records // In that case, parent no longer has to be ModuleFilePath, but can be SourcePath, etc... export function getKeysOf( schemas: Record, - sources: Record, + sources: Record, parent: ModuleFilePath, keyOfRecord?: string, // NOTE: if this is defined we find keys of this specific record, if not we find all potential references ): SourcePath[] { @@ -32,7 +32,7 @@ export function getKeysOf( const go = ( sourcePath: SourcePath, schema: SerializedSchema | undefined, - source: Json, + source: Source, ) => { if (schema === undefined) { console.error(`Schema not found for ${sourcePath}`); @@ -64,7 +64,7 @@ export function getKeysOf( if (isObjectSource(source) || isRecordSource(source)) { for (const key in source) { // NOTE: for object we are uncertain if we should use the source or the schema to get the keys. Currently we use the schema.items in other places, but source is more correct perhaps? Or perhaps not? We are not sure... - const sourceValue = source?.[key]; + const sourceValue = (source as Record)[key]; const schemaValue = schema.type === "object" ? schema.items?.[key] : schema.item; if (sourceValue) { @@ -85,7 +85,7 @@ export function getKeysOf( const schemaKey = schema.key; if (typeof schemaKey === "string") { if (isObjectSource(source)) { - const itemKey = source[schemaKey]; + const itemKey = (source as Record)[schemaKey]; if (typeof itemKey === "string") { const schemaOfItem = (schema.items as SerializedObjectSchema[]) .filter((item) => item.type === "object") @@ -144,14 +144,14 @@ function sourcePathConcat( )}` as SourcePath; } -function isObjectSource(source: Json): source is Record { +function isObjectSource(source: Source): source is Record { return isRecordSource(source); } -function isRecordSource(source: Json): source is Record { - return typeof source === "object" && !!source && !isJsonArray(source); +function isRecordSource(source: Source): source is Record { + return typeof source === "object" && !!source && !Array.isArray(source); } -function isArrayOfSource(source: Json): source is Json[] { - return typeof source === "object" && !!source && isJsonArray(source); +function isArrayOfSource(source: Source): source is Json[] { + return typeof source === "object" && !!source && Array.isArray(source); } diff --git a/packages/ui/spa/components/getNavPath.ts b/packages/ui/spa/components/getNavPath.ts index 72cd9f1f7..cab1b6a10 100644 --- a/packages/ui/spa/components/getNavPath.ts +++ b/packages/ui/spa/components/getNavPath.ts @@ -1,9 +1,9 @@ import { SourcePath, ModuleFilePath, - Json, SerializedSchema, Internal, + Source, } from "@valbuild/core"; import { resolvePatchPath } from "../resolvePatchPath"; @@ -28,7 +28,7 @@ function isSchemaNavStop( export function getNavPathFromAll( requestedPath: SourcePath | ModuleFilePath, - allSources: Record, + allSources: Record, schemas: Record | undefined, ): SourcePath | ModuleFilePath | null { if (!schemas) { diff --git a/packages/ui/spa/components/getRouteReferences.test.ts b/packages/ui/spa/components/getRouteReferences.test.ts index 9c72fd949..cfa86a37c 100644 --- a/packages/ui/spa/components/getRouteReferences.test.ts +++ b/packages/ui/spa/components/getRouteReferences.test.ts @@ -1,12 +1,11 @@ import { Internal, - Json, ModuleFilePath, SerializedSchema, ValModule, + Source, initVal, } from "@valbuild/core"; -import { SelectorSource } from "@valbuild/core"; import { getRouteReferences } from "./getRouteReferences"; const { s, c } = initVal(); @@ -326,9 +325,9 @@ describe("getRouteReferences", () => { }); }); -function getTestData(valModules: ValModule[]) { +function getTestData(valModules: ValModule[]) { const schemas: Record = {}; - const sources: Record = {}; + const sources: Record = {}; for (const valModule of valModules) { const moduleFilePath = getModuleFilePath(valModule); schemas[moduleFilePath] = getSchema(valModule); @@ -337,13 +336,11 @@ function getTestData(valModules: ValModule[]) { return { schemas, sources }; } -function getModuleFilePath( - valModule: ValModule, -): ModuleFilePath { +function getModuleFilePath(valModule: ValModule): ModuleFilePath { return Internal.getValPath(valModule) as unknown as ModuleFilePath; } -function getSchema(valModule: ValModule): SerializedSchema { +function getSchema(valModule: ValModule): SerializedSchema { const schema = Internal.getSchema(valModule)?.["executeSerialize"](); if (!schema) { throw new Error("Schema not found"); @@ -351,7 +348,7 @@ function getSchema(valModule: ValModule): SerializedSchema { return schema; } -function getSource(valModule: ValModule): Json { +function getSource(valModule: ValModule): Source { const source = Internal.getSource(valModule); if (!source) { throw new Error("Source not found"); diff --git a/packages/ui/spa/components/getRouteReferences.ts b/packages/ui/spa/components/getRouteReferences.ts index 13bb73047..16a3db334 100644 --- a/packages/ui/spa/components/getRouteReferences.ts +++ b/packages/ui/spa/components/getRouteReferences.ts @@ -1,12 +1,11 @@ import { - Json, ModuleFilePath, ModuleFilePathSep, + Source, SerializedObjectSchema, SerializedSchema, SourcePath, } from "@valbuild/core"; -import { isJsonArray } from "../utils/isJsonArray"; /** * Find all s.route() fields that have a value matching the given route key @@ -15,7 +14,7 @@ import { isJsonArray } from "../utils/isJsonArray"; */ export function getRouteReferences( schemas: Record, - sources: Record, + sources: Record, routeKey: string, ): SourcePath[] { const results: SourcePath[] = []; @@ -23,7 +22,7 @@ export function getRouteReferences( const go = ( sourcePath: SourcePath, schema: SerializedSchema | undefined, - source: Json, + source: Source | undefined, ) => { if (schema === undefined) { return; @@ -38,7 +37,7 @@ export function getRouteReferences( } else if (schema.type === "object" || schema.type === "record") { if (isObjectSource(source)) { for (const key in source) { - const sourceValue = source?.[key]; + const sourceValue = (source as Record)[key]; const schemaValue = schema.type === "object" ? schema.items?.[key] : schema.item; if (sourceValue) { @@ -59,7 +58,7 @@ export function getRouteReferences( const schemaKey = schema.key; if (typeof schemaKey === "string") { if (isObjectSource(source)) { - const itemKey = source[schemaKey]; + const itemKey = (source as Record)[schemaKey]; if (typeof itemKey === "string") { const schemaOfItem = (schema.items as SerializedObjectSchema[]) .filter((item) => item.type === "object") @@ -103,10 +102,12 @@ function sourcePathConcat( )}` as SourcePath; } -function isObjectSource(source: Json): source is Record { - return typeof source === "object" && !!source && !isJsonArray(source); +function isObjectSource( + source: Source | undefined, +): source is Record { + return typeof source === "object" && !!source && !Array.isArray(source); } -function isArrayOfSource(source: Json): source is Json[] { - return typeof source === "object" && !!source && isJsonArray(source); +function isArrayOfSource(source: Source | undefined): source is Source[] { + return typeof source === "object" && !!source && Array.isArray(source); } diff --git a/packages/ui/spa/resolvePatchPath.ts b/packages/ui/spa/resolvePatchPath.ts index cb592d568..331ea933d 100644 --- a/packages/ui/spa/resolvePatchPath.ts +++ b/packages/ui/spa/resolvePatchPath.ts @@ -1,28 +1,27 @@ import { SerializedSchema, - Json, ModulePath, JsonObject, SerializedObjectSchema, SerializedObjectUnionSchema, SerializedStringUnionSchema, + Source, } from "@valbuild/core"; -import { isJsonArray } from "./utils/isJsonArray"; export function resolvePatchPath( patchPath: string[], schema: SerializedSchema | undefined, - source: Json | undefined, + source: Source | undefined, ): | { success: true; modulePath: ModulePath; - source: Json; + source: Source; schema: SerializedSchema; allResolved: { modulePath: ModulePath; schema: SerializedSchema; - source: Json; + source: Source; }[]; } | { success: false; error: string } { @@ -52,11 +51,11 @@ export function resolvePatchPath( }; } let currentSchema: SerializedSchema = schema; - let currentSource: Json = source; + let currentSource: Source = source; const allResolved: { modulePath: ModulePath; schema: SerializedSchema; - source: Json; + source: Source; }[] = [ { modulePath: current as ModulePath, @@ -278,7 +277,7 @@ export function resolvePatchPath( }; } else if ( typeof currentSource === "object" && - isJsonArray(currentSource) + Array.isArray(currentSource) ) { if (!Number.isSafeInteger(Number(part))) { return { @@ -295,7 +294,7 @@ export function resolvePatchPath( typeof currentSource === "object" && !Array.isArray(currentSource) ) { - currentSource = currentSource[part]; + currentSource = (currentSource as Record)[part]; } else if ( typeof currentSource === "string" || typeof currentSource === "number" || @@ -348,7 +347,7 @@ function getObjectSourceOrError( patchPath: string[], part: string, i: number, - source: Json, + source: Source, expectedType: string, ): | { diff --git a/packages/ui/spa/search/createSearchIndex.ts b/packages/ui/spa/search/createSearchIndex.ts index cb474db4b..24a3290c1 100644 --- a/packages/ui/spa/search/createSearchIndex.ts +++ b/packages/ui/spa/search/createSearchIndex.ts @@ -1,17 +1,16 @@ import { FILE_REF_PROP, Internal, - Json, ModuleFilePath, ModulePath, + Source, SerializedSchema, SourcePath, } from "@valbuild/core"; import FlexSearch, { Index } from "flexsearch"; -import { isJsonArray } from "../utils/isJsonArray"; function rec( - source: Json, + source: Source, schema: SerializedSchema, path: SourcePath, sourceIndex: Index, @@ -79,7 +78,7 @@ function rec( subPath, ); } else if (source && typeof source === "object") { - if (isJsonArray(source)) { + if (Array.isArray(source)) { throw new Error( `Object schema does not have source of correct type: array, key: ${key} for ${path}`, ); @@ -88,7 +87,13 @@ function rec( `Object schema does is missing required key: ${key} in ${path}`, ); } else { - rec(source[key], subSchema, subPath, sourceIndex, sourcePathIndex); + rec( + (source as { [key: string]: Source })[key], + subSchema, + subPath, + sourceIndex, + sourcePathIndex, + ); } } else { throw new Error( @@ -117,10 +122,13 @@ function rec( } else if ( source && typeof source === "object" && - !isJsonArray(source) && + !Array.isArray(source) && schemaKey in source ) { - return schemaAtKey.value === source[schemaKey]; + return ( + schemaAtKey.value === + (source as { [key: string]: unknown })[schemaKey] + ); } else { throw new Error( `Union schema must have sub object with literal key but has: ${item.items[schemaKey]} for ${path}`, @@ -237,9 +245,9 @@ function rec( } } -function stringifyRichText(source: Json): string { +function stringifyRichText(source: Source): string { let res = ""; - function rec(child: Json): void { + function rec(child: Source): void { if (typeof child === "string") { res += child; } else { @@ -353,7 +361,7 @@ function addTokenizedSourcePath( } const debugPerf = true; export function createSearchIndex( - modules: Record, + modules: Record, ): Index { if (debugPerf) { console.time("indexing"); diff --git a/packages/ui/spa/search/search.test.ts b/packages/ui/spa/search/search.test.ts index 2ec010936..b9939b90d 100644 --- a/packages/ui/spa/search/search.test.ts +++ b/packages/ui/spa/search/search.test.ts @@ -1,11 +1,10 @@ import { Internal, - Json, ModuleFilePath, SerializedSchema, - SelectorSource, ValModule, initVal, + Source, } from "@valbuild/core"; import { createSearchIndex } from "./createSearchIndex"; import { search } from "."; @@ -170,10 +169,10 @@ describe("search", () => { }); }); -function createTestDate(data: ValModule[]) { +function createTestDate(data: ValModule[]) { const res: Record< ModuleFilePath, - { source: Json; schema: SerializedSchema } + { source: Source; schema: SerializedSchema } > = {}; for (const m of data) { res[Internal.getValPath(m) as unknown as ModuleFilePath] = { diff --git a/packages/ui/spa/search/search.worker.ts b/packages/ui/spa/search/search.worker.ts index fdaa59655..6fb9cd946 100644 --- a/packages/ui/spa/search/search.worker.ts +++ b/packages/ui/spa/search/search.worker.ts @@ -45,8 +45,8 @@ function buildIndex( schema.type === "keyOf" || schema.type === "route" ) { - searchText = source.toString(); - label = source.toString(); + searchText = source?.toString() ?? ""; + label = source?.toString() ?? ""; } else if (schema.type === "literal") { searchText = schema.value.toString(); label = schema.value.toString(); diff --git a/packages/ui/spa/utils/traverseSchemaSource.test.ts b/packages/ui/spa/utils/traverseSchemaSource.test.ts index d61d26444..d77134bd1 100644 --- a/packages/ui/spa/utils/traverseSchemaSource.test.ts +++ b/packages/ui/spa/utils/traverseSchemaSource.test.ts @@ -1,6 +1,5 @@ import { Internal, - Json, ModuleFilePath, SourcePath, ValModule, @@ -18,7 +17,7 @@ describe("traverseSchemaSource", () => { value: "hello world", }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -32,7 +31,7 @@ describe("traverseSchemaSource", () => { value: 42, }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -46,7 +45,7 @@ describe("traverseSchemaSource", () => { { value: true }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -92,7 +91,7 @@ describe("traverseSchemaSource", () => { file: c.file("/public/val/test.pdf"), }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; source: Json }> = []; + const visited: Array<{ path: SourcePath; source: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, source }); }); @@ -106,7 +105,7 @@ describe("traverseSchemaSource", () => { image: c.image("/public/val/test.jpg"), }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; source: Json }> = []; + const visited: Array<{ path: SourcePath; source: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, source }); }); @@ -132,7 +131,7 @@ describe("traverseSchemaSource", () => { }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -156,7 +155,7 @@ describe("traverseSchemaSource", () => { }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -175,7 +174,7 @@ describe("traverseSchemaSource", () => { { items: ["foo", "bar", "baz"] }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -201,7 +200,7 @@ describe("traverseSchemaSource", () => { { item: { type: "text", content: "Hello" } }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -220,7 +219,7 @@ describe("traverseSchemaSource", () => { { value: "foo" }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -236,7 +235,7 @@ describe("traverseSchemaSource", () => { date: "2021-01-01", }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -257,7 +256,7 @@ describe("traverseSchemaSource", () => { { key: "key1" }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -273,7 +272,7 @@ describe("traverseSchemaSource", () => { { value: "fixed" }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -287,7 +286,7 @@ describe("traverseSchemaSource", () => { route: "/home", }); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; value: Json }> = []; + const visited: Array<{ path: SourcePath; value: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, value: source }); }); @@ -384,7 +383,7 @@ describe("traverseSchemaSource", () => { }, ); const { schema, source, path } = getTestData(module); - const visited: Array<{ path: SourcePath; source: Json }> = []; + const visited: Array<{ path: SourcePath; source: SelectorSource }> = []; traverseSchemaSource(source, schema, path, ({ source, path }) => { visited.push({ path, source }); }); diff --git a/packages/ui/spa/utils/traverseSchemaSource.ts b/packages/ui/spa/utils/traverseSchemaSource.ts index 4392be90d..d61581fe9 100644 --- a/packages/ui/spa/utils/traverseSchemaSource.ts +++ b/packages/ui/spa/utils/traverseSchemaSource.ts @@ -1,12 +1,11 @@ import { FILE_REF_PROP, - Json, ModuleFilePathSep, + Source, SerializedObjectSchema, SerializedSchema, SourcePath, } from "@valbuild/core"; -import { isJsonArray } from "./isJsonArray"; /** * Traverses a schema and source pair, calling a callback for each leaf node. @@ -18,11 +17,11 @@ import { isJsonArray } from "./isJsonArray"; * @param callback - Function called for each traversable node with { source, schema, path } */ export function traverseSchemaSource( - source: Json, + source: Source, schema: SerializedSchema, path: SourcePath, callback: (opts: { - source: Json; + source: Source; schema: SerializedSchema; path: SourcePath; }) => void, @@ -125,7 +124,11 @@ export function traverseSchemaSource( // Handle object and record if (schema.type === "object" || schema.type === "record") { - if (typeof source !== "object" || source === null || isJsonArray(source)) { + if ( + typeof source !== "object" || + source === null || + Array.isArray(source) + ) { return; } for (const key in source) { @@ -135,7 +138,12 @@ export function traverseSchemaSource( continue; } const subPath = sourcePathConcat(path, key); - traverseSchemaSource(source[key], subSchema, subPath, callback); + traverseSchemaSource( + (source as Record)[key], + subSchema, + subPath, + callback, + ); } return; } @@ -148,10 +156,10 @@ export function traverseSchemaSource( if ( source && typeof source === "object" && - !isJsonArray(source) && + !Array.isArray(source) && schemaKey in source ) { - const itemKey = source[schemaKey]; + const itemKey = (source as Record)[schemaKey]; if (typeof itemKey === "string") { const schemaOfItem = (schema.items as SerializedObjectSchema[]) .filter((item) => item.type === "object") @@ -205,9 +213,9 @@ function sourcePathConcat( * Flattens richtext source to a plain string, extracting only text content. * Used for indexing richtext content in search. */ -export function flattenRichText(source: Json): string { +export function flattenRichText(source: Source): string { let res = ""; - function rec(child: Json): void { + function rec(child: Source): void { if (typeof child === "string") { res += child; } else { From f9ac1dc8de09061bfa4ca5d973e0cc32e21d707f Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Tue, 24 Feb 2026 19:04:33 +0000 Subject: [PATCH 13/32] Fix missing moduleMetadata when calling nullable --- packages/core/src/schema/file.ts | 8 +++++++- packages/core/src/schema/image.ts | 8 +++++++- 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index 7050b11a5..94b5c3b37 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -314,7 +314,13 @@ export class FileSchema< } nullable(): FileSchema { - return new FileSchema(this.options, true, this.isRemote); + return new FileSchema( + this.options, + true, + this.isRemote, + this.customValidateFunctions as CustomValidateFunction[], + this.moduleMetadata, + ); } protected executeSerialize(): SerializedSchema { diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index 2c17a005c..f732df917 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -347,7 +347,13 @@ export class ImageSchema< } nullable(): ImageSchema { - return new ImageSchema(this.options, true, this.isRemote); + return new ImageSchema( + this.options, + true, + this.isRemote, + this.customValidateFunctions as CustomValidateFunction[], + this.moduleMetadata, + ); } protected executeSerialize(): SerializedSchema { From fa2e7ded250742458d0c5cbfd8099c4c23b860b3 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Tue, 24 Feb 2026 19:04:59 +0000 Subject: [PATCH 14/32] Update val.modules with media.val --- examples/next/val.modules.ts | 1 + 1 file changed, 1 insertion(+) diff --git a/examples/next/val.modules.ts b/examples/next/val.modules.ts index 81e505361..88a1873ba 100644 --- a/examples/next/val.modules.ts +++ b/examples/next/val.modules.ts @@ -5,6 +5,7 @@ export default modules(config, [ { def: () => import("./content/authors.val") }, { def: () => import("./app/blogs/[blog]/page.val") }, { def: () => import("./app/generic/[[...path]]/page.val") }, + { def: () => import("./content/media.val") }, { def: () => import("./app/page.val") }, { def: () => import("./app/external.val") }, ]); From 27cae727e40399daab65e50f1448ac48f57b6fad Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Wed, 25 Feb 2026 16:47:11 +0000 Subject: [PATCH 15/32] Upload images / files to referenced modules --- .../ui/spa/components/fields/FileField.tsx | 109 +++++++++++++----- .../ui/spa/components/fields/ImageField.tsx | 73 +++++++++++- 2 files changed, 150 insertions(+), 32 deletions(-) diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index e4cefa993..dcaa8b92e 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -5,6 +5,7 @@ import { VAL_EXTENSION, ConfigDirectory, Internal, + ModuleFilePath, SourcePath, FILE_REF_SUBTYPE_TAG, SerializedImageSchema, @@ -37,6 +38,7 @@ import { useEffect } from "react"; import { useValPortal } from "../ValPortalProvider"; import { MediaPicker } from "../MediaPicker/MediaPicker"; import type { GalleryEntry } from "../MediaPicker/MediaPicker"; +import { GalleryUploadTarget } from "../MediaPicker/GalleryUploadTarget"; const textEncoder = new TextEncoder(); export async function createFilePatch( @@ -54,7 +56,8 @@ export async function createFilePatch( remoteHost: string; } | null, directory: ConfigDirectory = "/public/val", -): Promise { + skipMetadataInReplace: boolean = false, +): Promise<{ patch: Patch; filePath: string }> { const newFilePath = Internal.createFilename( data, filename, @@ -62,7 +65,7 @@ export async function createFilePatch( fileHash, ); if (!newFilePath || !metadata) { - return []; + return { patch: [], filePath: "" }; } const filePath = `${directory}/${newFilePath}`; @@ -84,26 +87,29 @@ export async function createFilePatch( filePath: `${directory.slice(1) as `public/val`}/${newFilePath}`, }) : filePath; - return [ - { - value: { - [FILE_REF_PROP]: ref, - [VAL_EXTENSION]: remote ? "remote" : "file", - ...(subType !== "file" ? { [FILE_REF_SUBTYPE_TAG]: subType } : {}), + return { + patch: [ + { + value: { + [FILE_REF_PROP]: ref, + [VAL_EXTENSION]: remote ? "remote" : "file", + ...(subType !== "file" ? { [FILE_REF_SUBTYPE_TAG]: subType } : {}), + ...(skipMetadataInReplace ? {} : { metadata }), + }, + op: "replace", + path, + }, + { + value: data, metadata, + op: "file", + path, + filePath: ref, + remote: remote !== null, }, - op: "replace", - path, - }, - { - value: data, - metadata, - op: "file", - path, - filePath: ref, - remote: remote !== null, - }, - ]; + ], + filePath, + }; } export function FileField({ path }: { path: SourcePath }) { @@ -117,7 +123,10 @@ export function FileField({ path }: { path: SourcePath }) { const [error, setError] = useState(null); const [url, setUrl] = useState(null); const [loading, setLoading] = useState(false); - const { addPatch, patchPath, addAndUploadPatchWithFileOps } = + const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< + string | null + >(null); + const { addPatch, patchPath, addAndUploadPatchWithFileOps, addModuleFilePatch } = useAddPatch(path); const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( @@ -148,6 +157,18 @@ export function FileField({ path }: { path: SourcePath }) { } } }, [sourceAtPath]); + useEffect(() => { + if ( + schemaAtPath.status === "success" && + schemaAtPath.data.type === "file" && + schemaAtPath.data.moduleMetadata + ) { + const keys = Object.keys(schemaAtPath.data.moduleMetadata); + if (keys.length >= 1 && selectedGalleryModulePath === null) { + setSelectedGalleryModulePath(keys[0]); + } + } + }, [schemaAtPath]); useEffect(() => { // We want to show video if only video is accepted // If source is defined we also show a video if the mimeType is video @@ -271,6 +292,15 @@ export function FileField({ path }: { path: SourcePath }) { )} )} + {schemaAtPath.data.moduleMetadata && + Object.keys(schemaAtPath.data.moduleMetadata).length > 1 && ( + + )} {schemaAtPath.data.moduleMetadata && Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( { + .then(({ patch, filePath }) => { setLoading(true); setProgressPercentage(0); + let hasError = false; addAndUploadPatchWithFileOps( patch, type, (errorMessage) => { + hasError = true; setUrl(prevUrl); setError(errorMessage); }, @@ -403,10 +437,33 @@ export function FileField({ path }: { path: SourcePath }) { Math.round(overallProgress * 100), ); }, - ).finally(() => { - setProgressPercentage(null); - setLoading(false); - }); + ) + .then(() => { + if ( + !hasError && + selectedGalleryModulePath && + filePath && + metadata?.mimeType + ) { + addModuleFilePatch( + selectedGalleryModulePath as ModuleFilePath, + [ + { + op: "add", + path: [filePath], + value: { + mimeType: metadata.mimeType, + } as JSONValue, + }, + ], + "record", + ); + } + }) + .finally(() => { + setProgressPercentage(null); + setLoading(false); + }); }) .catch((err) => { console.error("Failed to create file patch", err); diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index a6d8b71b6..141b2ff99 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -1,6 +1,7 @@ import { ImageMetadata, Internal, + ModuleFilePath, SourcePath, VAL_EXTENSION, FILE_REF_PROP, @@ -32,6 +33,7 @@ import { Button } from "../designSystem/button"; import { useValPortal } from "../ValPortalProvider"; import { MediaPicker } from "../MediaPicker/MediaPicker"; import type { GalleryEntry } from "../MediaPicker/MediaPicker"; +import { GalleryUploadTarget } from "../MediaPicker/GalleryUploadTarget"; import { JSONValue } from "@valbuild/core/patch"; export function ImageField({ path }: { path: SourcePath }) { @@ -47,7 +49,10 @@ export function ImageField({ path }: { path: SourcePath }) { const [error, setError] = useState(null); const [url, setUrl] = useState(null); const [loading, setLoading] = useState(false); - const { addPatch, patchPath, addAndUploadPatchWithFileOps } = + const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< + string | null + >(null); + const { addPatch, patchPath, addAndUploadPatchWithFileOps, addModuleFilePatch } = useAddPatch(path); const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( @@ -56,6 +61,18 @@ export function ImageField({ path }: { path: SourcePath }) { const maybeSourceData = "data" in sourceAtPath && sourceAtPath.data; const maybeClientSideOnly = sourceAtPath.status === "success" && sourceAtPath.clientSideOnly; + useEffect(() => { + if ( + schemaAtPath.status === "success" && + schemaAtPath.data.type === "image" && + schemaAtPath.data.moduleMetadata + ) { + const keys = Object.keys(schemaAtPath.data.moduleMetadata); + if (keys.length >= 1 && selectedGalleryModulePath === null) { + setSelectedGalleryModulePath(keys[0]); + } + } + }, [schemaAtPath]); useEffect(() => { if (maybeSourceData) { if (maybeSourceData.metadata) { @@ -326,6 +343,15 @@ export function ImageField({ path }: { path: SourcePath }) { )} )} + {schemaAtPath.data.moduleMetadata && + Object.keys(schemaAtPath.data.moduleMetadata).length > 1 && ( + + )} {schemaAtPath.data.moduleMetadata && Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( { + .then(({ patch, filePath }) => { setLoading(true); setProgressPercentage(0); + let hasError = false; addAndUploadPatchWithFileOps( patch, type, (errorMessage) => { + hasError = true; setUrl(prevUrl); setError(errorMessage); }, @@ -415,10 +445,41 @@ export function ImageField({ path }: { path: SourcePath }) { (totalBytes * totalFiles); setProgressPercentage(Math.round(overallProgress * 100)); }, - ).finally(() => { - setProgressPercentage(null); - setLoading(false); - }); + ) + .then(() => { + if ( + !hasError && + selectedGalleryModulePath && + filePath && + metadata?.mimeType && + metadata.width !== undefined && + metadata.height !== undefined + ) { + addModuleFilePatch( + selectedGalleryModulePath as ModuleFilePath, + [ + { + op: "add", + path: [filePath], + value: { + width: metadata.width, + height: metadata.height, + mimeType: metadata.mimeType, + alt: + typeof metadata.alt === "string" + ? metadata.alt + : null, + } as JSONValue, + }, + ], + "record", + ); + } + }) + .finally(() => { + setProgressPercentage(null); + setLoading(false); + }); }) .catch((err) => { console.error("Failed to create file patch", err); From 81c6f8aaaac0f252c903e00f4d02ffddbc91cb43 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Wed, 25 Feb 2026 16:47:41 +0000 Subject: [PATCH 16/32] Show a clear error if referenced module is missing in val.modules --- .../ui/spa/components/fields/FileField.tsx | 21 ++++++++++++++++--- .../ui/spa/components/fields/ImageField.tsx | 21 ++++++++++++++++--- 2 files changed, 36 insertions(+), 6 deletions(-) diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index dcaa8b92e..fbcdcc8c3 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -23,6 +23,7 @@ import { useSchemaAtPath, useShallowSourceAtPath, useAddPatch, + useSchemas, } from "../ValFieldProvider"; import { useCurrentRemoteFileBucket, @@ -117,6 +118,7 @@ export function FileField({ path }: { path: SourcePath }) { const config = useValConfig(); const currentRemoteFileBucket = useCurrentRemoteFileBucket(); const remoteFiles = useRemoteFiles(); + const schemas = useSchemas(); const schemaAtPath = useSchemaAtPath(path); const sourceAtPath = useShallowSourceAtPath(path, type); const [showAsVideo, setShowAsVideo] = useState(false); @@ -234,7 +236,13 @@ export function FileField({ path }: { path: SourcePath }) { schemaAtPath.data.type === "file" && schemaAtPath.data.remote && remoteFiles.status !== "ready"; - const disabled = remoteFileUploadDisabled; + const missingModules = + schemaAtPath.data.moduleMetadata && schemas.status === "success" + ? Object.keys(schemaAtPath.data.moduleMetadata).filter( + (modulePath) => !schemas.data[modulePath as ModuleFilePath], + ) + : []; + const disabled = remoteFileUploadDisabled || missingModules.length > 0; const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -268,6 +276,13 @@ export function FileField({ path }: { path: SourcePath }) { return ( + {showAltColumn ? ( +
+ +
+ ) : ( +
+ +
+ )} + {showAltColumn && ( +
+ +
+ )}
-
Folder
@@ -116,8 +152,21 @@ export function FileGalleryListView({ {rowVirtualizer.getVirtualItems().map((virtualRow) => { const file = files[virtualRow.index]; const hasErrors = - file.validationErrors && file.validationErrors.length > 0; + (file.validationErrors && file.validationErrors.length > 0) || + (file.fieldSpecificErrors && + Object.values(file.fieldSpecificErrors).some( + (errs) => errs && errs.length > 0, + )); + const isFirstRow = virtualRow.index === 0; + const isLastRow = virtualRow.index === files.length - 1; + const showTopErrorBorder = + hasErrors && + (virtualRow.index === 0 || + !( + files[virtualRow.index - 1].validationErrors && + files[virtualRow.index - 1].validationErrors!.length > 0 + )); return (
onItemClick(virtualRow.index)} className={cn( - "absolute left-0 top-0 grid w-full cursor-pointer border-b transition-colors", + "absolute left-0 top-0 grid w-full cursor-pointer border border-b-0 transition-colors", + isFirstRow && "border-t-0", + isLastRow && "border-b", gridCols, - hasErrors - ? "border-destructive/50 bg-destructive/5 hover:bg-destructive/10" - : "border-border-secondary hover:bg-bg-secondary", + "border-border-secondary hover:bg-bg-secondary", + hasErrors && + "border border-bg-error-primary hover:border-bg-error-primary-hover", + !showTopErrorBorder && hasErrors && "border-t-0", + isLastRow && "rounded-b-lg", )} style={{ transform: `translateY(${virtualRow.start}px)`, }} title={ - hasErrors ? file.validationErrors!.join(", ") : undefined + hasErrors ? file.validationErrors?.join(", ") : undefined } >
@@ -143,21 +196,31 @@ export function FileGalleryListView({
-
- - {file.filename} - -
+ {showAltColumn ? ( + <> +
+ + {file.metadata.alt ?? ""} + +
+
+ + {file.filename} + +
+ + ) : ( +
+ + {file.filename} + +
+ )}
{formatMimeType(file.metadata.mimeType)}
-
- - {file.folder} - -
); })} diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx index 4f442a181..80c786fb6 100644 --- a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -1,5 +1,5 @@ import * as React from "react"; -import { Check, ExternalLink, Pencil } from "lucide-react"; +import { Check, ExternalLink, Pencil, Trash2 } from "lucide-react"; import { Dialog, DialogContent, @@ -11,6 +11,7 @@ import { Input } from "../designSystem/input"; import { FilePreview } from "./FilePreview"; import { FilenameInput } from "./FilenameInput"; import type { GalleryFile } from "./types"; +import { FieldValidationError } from "../FieldValidationError"; interface FilePropertiesModalProps { file: GalleryFile | null; @@ -19,6 +20,7 @@ interface FilePropertiesModalProps { onOpenChange: (open: boolean) => void; onFileRename?: (index: number, newFilename: string) => void; onAltTextChange?: (index: number, newAltText: string) => void; + onFileDelete?: (index: number) => void; imageMode?: boolean; loading?: boolean; disabled?: boolean; @@ -32,43 +34,18 @@ export function FilePropertiesModal({ onOpenChange, onFileRename, onAltTextChange, + onFileDelete, imageMode, loading, disabled, container, }: FilePropertiesModalProps) { - const [isEditingAlt, setIsEditingAlt] = React.useState(false); - const [editedAlt, setEditedAlt] = React.useState(""); - - React.useEffect(() => { - if (file) { - setEditedAlt(file.metadata.alt ?? ""); - setIsEditingAlt(false); - } - }, [file]); - if (!file || fileIndex === null) return null; const handleFilenameChange = (newFilename: string) => { onFileRename?.(fileIndex, newFilename); }; - const handleSaveAlt = () => { - if (editedAlt !== (file.metadata.alt ?? "")) { - onAltTextChange?.(fileIndex, editedAlt); - } - setIsEditingAlt(false); - }; - - const handleAltKeyDown = (e: React.KeyboardEvent) => { - if (e.key === "Enter") { - handleSaveAlt(); - } else if (e.key === "Escape") { - setEditedAlt(file.metadata.alt ?? ""); - setIsEditingAlt(false); - } - }; - const handleOpenInNewTab = () => { window.open(file.url, "_blank", "noopener,noreferrer"); }; @@ -108,58 +85,39 @@ export function FilePropertiesModal({ {/* Alt Text (only for images in imageMode) */} {imageMode && isImage && onAltTextChange && ( -
+
0, + })} + > - {isEditingAlt ? ( -
- setEditedAlt(e.target.value)} - onKeyDown={handleAltKeyDown} - autoFocus - placeholder="Describe this image..." - className="h-8 flex-1 text-sm" - /> - -
- ) : ( -
- - {file.metadata.alt || "No alt text"} - - -
- )} + +
+ { + onAltTextChange?.(fileIndex, e.target.value); + }} + autoFocus + placeholder="Describe this image..." + /> + {file.fieldSpecificErrors?.alt && + file.fieldSpecificErrors.alt.length > 0 && ( +
    + {file.fieldSpecificErrors.alt.map((error, i) => ( +
  • + +
    • + ))} +
+ )} +
)} @@ -224,6 +182,20 @@ export function FilePropertiesModal({ Open in New Tab + {onFileDelete && fileIndex !== null && ( + + )}
diff --git a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx index ee1de4567..e3efa4aeb 100644 --- a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx +++ b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx @@ -2,6 +2,8 @@ import type { Meta, StoryObj } from "@storybook/react"; import { useState } from "react"; import { FileGallery } from "../FileGallery"; import type { GalleryFile } from "../types"; +import { ValPortalProvider } from "../../ValPortalProvider"; +import { ValThemeProvider } from "../../ValThemeProvider"; const meta: Meta = { title: "Components/FileGallery", @@ -10,6 +12,15 @@ const meta: Meta = { layout: "padded", }, tags: ["autodocs"], + decorators: [ + (Story) => ( + {}} config={undefined}> + + + + + ), + ], }; export default meta; diff --git a/packages/ui/spa/components/FileGallery/types.ts b/packages/ui/spa/components/FileGallery/types.ts index dc642d20d..bde0a623e 100644 --- a/packages/ui/spa/components/FileGallery/types.ts +++ b/packages/ui/spa/components/FileGallery/types.ts @@ -12,17 +12,21 @@ export interface GalleryFile { metadata: FileMetadata; createdAt?: Date; validationErrors?: string[]; + fieldSpecificErrors?: { + alt?: string[]; + }; } export type ViewMode = "masonry" | "grid" | "list"; -export type SortField = "name" | "type"; +export type SortField = "name" | "description" | "type"; export type SortDirection = "asc" | "desc"; export interface FileGalleryProps { files: GalleryFile[]; onFileRename?: (index: number, newFilename: string) => void; onAltTextChange?: (index: number, newAltText: string) => void; + onFileDelete?: (index: number) => void; className?: string; defaultViewMode?: ViewMode; showSearch?: boolean; diff --git a/packages/ui/spa/components/Module.tsx b/packages/ui/spa/components/Module.tsx index 6b91ce4d2..3580a792e 100644 --- a/packages/ui/spa/components/Module.tsx +++ b/packages/ui/spa/components/Module.tsx @@ -99,6 +99,7 @@ export function Module({ path }: { path: SourcePath }) { // Check if the current schema is a router record const isCurrentRouter = schema.type === "record" && Boolean(schema.router); + const isMediaGallery = schema.type === "record" && Boolean(schema.mediaType); return (
@@ -137,9 +138,11 @@ export function Module({ path }: { path: SourcePath }) { {showNumber && ( #{Number(last.text)} )} -
- -
+ {!isMediaGallery && ( +
+ +
+ )}
{keyErrors.length > 0 && ( diff --git a/packages/ui/spa/components/designSystem/input.tsx b/packages/ui/spa/components/designSystem/input.tsx index c09091fac..520cf2cf5 100644 --- a/packages/ui/spa/components/designSystem/input.tsx +++ b/packages/ui/spa/components/designSystem/input.tsx @@ -10,7 +10,7 @@ const Input = React.forwardRef( { const newFilePath = Internal.createFilename( @@ -85,7 +84,7 @@ export async function createFilePatch( textEncoder, ), fileHash: remoteFileHash, - filePath: `${directory.slice(1) as `public/val`}/${newFilePath}`, + filePath: `${(directory ?? "/public/val").slice(1) as `public/val/${string}`}/${newFilePath}`, }) : filePath; return { @@ -254,6 +253,11 @@ export function FileField({ path }: { path: SourcePath }) { } return undefined; }, [schemaAtPath.data, referencedModule, schemas]); + const moduleDirectory = useMemo(() => { + if (!referencedModule || schemas.status !== "success") return undefined; + const moduleSchema = schemas.data[referencedModule as ModuleFilePath]; + return moduleSchema?.type === "record" ? moduleSchema.directory : undefined; + }, [referencedModule, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -424,7 +428,7 @@ export function FileField({ path }: { path: SourcePath }) { metadata, type, remoteData, - config.files?.directory, + moduleDirectory ?? config.files?.directory, false, ) .then(({ patch, filePath }) => { diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index e8392f65c..7f29b539b 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -193,6 +193,11 @@ export function ImageField({ path }: { path: SourcePath }) { } return undefined; }, [schemaAtPath.data, referencedModule, schemas]); + const moduleDirectory = useMemo(() => { + if (!referencedModule || schemas.status !== "success") return undefined; + const moduleSchema = schemas.data[referencedModule as ModuleFilePath]; + return moduleSchema?.type === "record" ? moduleSchema.directory : undefined; + }, [referencedModule, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -370,31 +375,31 @@ export function ImageField({ path }: { path: SourcePath }) { )} {referencedModule && ( - { - addPatch( - [ - { - op: "replace", - path: patchPath, - value: { - [FILE_REF_PROP]: entry.filePath, - [VAL_EXTENSION]: "file", - [FILE_REF_SUBTYPE_TAG]: "image", - metadata: entry.metadata as JSONValue, - }, + { + addPatch( + [ + { + op: "replace", + path: patchPath, + value: { + [FILE_REF_PROP]: entry.filePath, + [VAL_EXTENSION]: "file", + [FILE_REF_SUBTYPE_TAG]: "image", + metadata: entry.metadata as JSONValue, }, - ], - "image", - ); - }} - isImage - disabled={disabled} - portalContainer={portalContainer} - /> - )} + }, + ], + "image", + ); + }} + isImage + disabled={disabled} + portalContainer={portalContainer} + /> + )} @@ -434,7 +439,7 @@ export function ImageField({ path }: { path: SourcePath }) { metadata, type, remoteData, - config.files?.directory, + moduleDirectory ?? config.files?.directory, false, ) .then(({ patch, filePath }) => { diff --git a/packages/ui/spa/components/fields/ModuleGallery.tsx b/packages/ui/spa/components/fields/ModuleGallery.tsx index aadd137f4..6f28677a2 100644 --- a/packages/ui/spa/components/fields/ModuleGallery.tsx +++ b/packages/ui/spa/components/fields/ModuleGallery.tsx @@ -1,13 +1,20 @@ import * as React from "react"; -import { FileMetadata, ImageMetadata, Internal, SourcePath } from "@valbuild/core"; +import { + FileMetadata, + ImageMetadata, + Internal, + SourcePath, +} from "@valbuild/core"; +import { array } from "@valbuild/core/fp"; import { JSONValue, Patch } from "@valbuild/core/patch"; import { useAddPatch, useFilePatchIds, useSchemaAtPath, useSourceAtPath, - useValConfig, } from "../ValFieldProvider"; +import { useAllValidationErrors } from "../ValErrorProvider"; +import { sourcePathOfItem } from "../../utils/sourcePathOfItem"; import { ValidationErrors } from "../ValidationError"; import { FieldLoading } from "../FieldLoading"; import { FileGallery } from "../FileGallery/FileGallery"; @@ -34,9 +41,9 @@ export function ModuleGallery({ path }: { path: SourcePath }) { const source = useSourceAtPath(path); const schemaAtPath = useSchemaAtPath(path); const filePatchIds = useFilePatchIds(); - const config = useValConfig(); const { addPatch, patchPath, addAndUploadPatchWithFileOps } = useAddPatch(path); + const allValidationErrors = useAllValidationErrors() || {}; const inputRef = React.useRef(null); const [uploading, setUploading] = React.useState(false); @@ -53,26 +60,77 @@ export function ModuleGallery({ path }: { path: SourcePath }) { : null; const imageMode = schema?.mediaType === "images"; - const directory = - schema?.directory ?? config?.files?.directory ?? "/public/val"; + const directory = schema?.directory ?? "/public/val"; const accept = schema?.accept; const files: GalleryFile[] = rawSource ? Object.entries(rawSource).map(([ref, meta]) => { - const mimeType = - typeof meta.mimeType === "string" ? meta.mimeType : ""; + const mimeType = typeof meta.mimeType === "string" ? meta.mimeType : ""; const width = typeof meta.width === "number" ? meta.width : 0; const height = typeof meta.height === "number" ? meta.height : 0; const alt = typeof meta.alt === "string" ? meta.alt : undefined; + const itemPath = sourcePathOfItem(path, ref); + const genericValidationErrors = []; + const altSpecificValidationErrors = []; + for (const [errPath, errs] of Object.entries(allValidationErrors)) { + if (!errPath.startsWith(itemPath)) { + continue; + } + if (errPath === Internal.createValPathOfItem(itemPath, "alt")) { + altSpecificValidationErrors.push(...errs.map((err) => err.message)); + } else { + genericValidationErrors.push(...errs.map((err) => err.message)); + } + } + return { url: refToUrl(ref, filePatchIds), filename: ref.split("/").pop() || ref, folder: ref.substring(0, ref.lastIndexOf("/")), metadata: { mimeType, width, height, alt }, + fieldSpecificErrors: { + alt: + altSpecificValidationErrors.length > 0 + ? altSpecificValidationErrors + : undefined, + }, + validationErrors: + genericValidationErrors.length > 0 + ? genericValidationErrors + : undefined, }; }) : []; + const handleFileDelete = React.useCallback( + (index: number) => { + if (!rawSource) return; + const ref = Object.keys(rawSource)[index]; + if (!ref) return; + const patch: Patch = [ + { + op: "remove", + path: [...patchPath, ref] as unknown as array.NonEmptyArray, + }, + { + op: "file", + path: [...patchPath, ref], + filePath: ref, + value: null, + remote: false, + }, + ]; + setUploading(true); + addAndUploadPatchWithFileOps( + patch, + imageMode ? "image" : "file", + (msg) => setUploadError(msg), + () => {}, + ).finally(() => setUploading(false)); + }, + [rawSource, patchPath, imageMode, addAndUploadPatchWithFileOps], + ); + const handleAltTextChange = React.useCallback( (index: number, newAltText: string) => { if (!rawSource) return; @@ -82,7 +140,7 @@ export function ModuleGallery({ path }: { path: SourcePath }) { { op: "replace", path: [...patchPath, ref, "alt"], - value: newAltText || null, + value: newAltText, }, ]; addPatch(patch, "record"); @@ -118,7 +176,7 @@ export function ModuleGallery({ path }: { path: SourcePath }) { width: metadata.width, height: metadata.height, mimeType: metadata.mimeType, - alt: null, // default alt for new uploads + alt: null, // default alt for new uploads } as JSONValue, }, { @@ -138,7 +196,9 @@ export function ModuleGallery({ path }: { path: SourcePath }) { () => {}, ); }) - .catch(() => setUploadError("Could not upload image. Please try again.")) + .catch(() => + setUploadError("Could not upload image. Please try again."), + ) .finally(() => setUploading(false)); } else { readFile(ev) @@ -176,7 +236,9 @@ export function ModuleGallery({ path }: { path: SourcePath }) { () => {}, ); }) - .catch(() => setUploadError("Could not upload file. Please try again.")) + .catch(() => + setUploadError("Could not upload file. Please try again."), + ) .finally(() => setUploading(false)); } ev.target.value = ""; @@ -207,6 +269,7 @@ export function ModuleGallery({ path }: { path: SourcePath }) { files={files} imageMode={imageMode} onAltTextChange={imageMode ? handleAltTextChange : undefined} + onFileDelete={handleFileDelete} onUploadClick={() => inputRef.current?.click()} uploading={uploading} /> diff --git a/packages/ui/spa/hooks/useParent.ts b/packages/ui/spa/hooks/useParent.ts index f5ab2f682..1af2a34a4 100644 --- a/packages/ui/spa/hooks/useParent.ts +++ b/packages/ui/spa/hooks/useParent.ts @@ -31,6 +31,7 @@ export const isParentArray = ( parentSchemaAtPath: SerializedSchema | undefined, ) => maybeParentPath !== path && parentSchemaAtPath?.type === "array"; export const isRecord = (schema: SerializedSchema | undefined) => - schema?.type === "record"; + schema?.type === "record" && + !(schema.mediaType === "files" || schema.mediaType === "images"); export const isArray = (schema: SerializedSchema | undefined) => schema?.type === "array"; From e09436233b32ca18bd861122123f887a7d6469b5 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Wed, 4 Mar 2026 17:10:54 +0100 Subject: [PATCH 24/32] Update file gallery, image / file field --- packages/core/src/schema/image.ts | 10 ++ .../components/FileGallery/FileGallery.tsx | 2 + .../FileGallery/FilePropertiesModal.tsx | 107 +++++++++++-- .../stories/FileGallery.stories.tsx | 12 +- .../stories/FileProperties.stories.tsx | 4 + .../ui/spa/components/FileGallery/types.ts | 2 + .../ui/spa/components/fields/FileField.tsx | 48 +++--- .../ui/spa/components/fields/ImageField.tsx | 86 +++++------ .../spa/components/fields/ModuleGallery.tsx | 3 + .../ui/spa/components/getReferencedFiles.ts | 143 ++++++++++++++++++ packages/ui/spa/components/useKeysOf.ts | 1 + .../ui/spa/components/useReferencedFiles.ts | 34 +++++ 12 files changed, 371 insertions(+), 81 deletions(-) create mode 100644 packages/ui/spa/components/getReferencedFiles.ts create mode 100644 packages/ui/spa/components/useReferencedFiles.ts diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index 24555b36d..c956aaa2f 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -269,6 +269,16 @@ export class ImageSchema< } as ValidationErrors; } + const isReferencedModule = Object.keys(this.moduleMetadata).length > 0; + if (src.metadata === undefined && isReferencedModule) { + if (customValidationErrors.length === 0) { + return false; + } + return { + [path]: [...customValidationErrors], + } as ValidationErrors; + } + return { [path]: [ ...customValidationErrors, diff --git a/packages/ui/spa/components/FileGallery/FileGallery.tsx b/packages/ui/spa/components/FileGallery/FileGallery.tsx index c412afc8c..05ea093bd 100644 --- a/packages/ui/spa/components/FileGallery/FileGallery.tsx +++ b/packages/ui/spa/components/FileGallery/FileGallery.tsx @@ -24,6 +24,7 @@ import type { export function FileGallery({ files, + parentPath, onFileRename, onAltTextChange, onFileDelete, @@ -281,6 +282,7 @@ export function FileGallery({ onFileRename={onFileRename} onAltTextChange={onAltTextChange} onFileDelete={onFileDelete} + parentPath={parentPath} imageMode={imageMode} loading={loading} disabled={disabled} diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx index 80c786fb6..6a69ab8b3 100644 --- a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -1,5 +1,6 @@ import * as React from "react"; -import { Check, ExternalLink, Pencil, Trash2 } from "lucide-react"; +import { Check, ExternalLink, Link, Trash2 } from "lucide-react"; +import { Internal, ModuleFilePath } from "@valbuild/core"; import { Dialog, DialogContent, @@ -12,6 +13,23 @@ import { FilePreview } from "./FilePreview"; import { FilenameInput } from "./FilenameInput"; import type { GalleryFile } from "./types"; import { FieldValidationError } from "../FieldValidationError"; +import { useKeysOf } from "../useKeysOf"; +import { useNavigation } from "../ValRouter"; +import { ValPath } from "../ValPath"; +import { prettifyFilename } from "../../utils/prettifyFilename"; +import { + Popover, + PopoverContent, + PopoverTrigger, +} from "../designSystem/popover"; +import { + Command, + CommandEmpty, + CommandGroup, + CommandInput, + CommandItem, + CommandList, +} from "../designSystem/command"; interface FilePropertiesModalProps { file: GalleryFile | null; @@ -21,6 +39,7 @@ interface FilePropertiesModalProps { onFileRename?: (index: number, newFilename: string) => void; onAltTextChange?: (index: number, newAltText: string) => void; onFileDelete?: (index: number) => void; + parentPath?: string; imageMode?: boolean; loading?: boolean; disabled?: boolean; @@ -35,11 +54,16 @@ export function FilePropertiesModal({ onFileRename, onAltTextChange, onFileDelete, + parentPath, imageMode, loading, disabled, container, }: FilePropertiesModalProps) { + const refs = useKeysOf(parentPath as ModuleFilePath | undefined, file?.ref); + const { navigate, currentSourcePath } = useNavigation(); + const [refsOpen, setRefsOpen] = React.useState(false); + if (!file || fileIndex === null) return null; const handleFilenameChange = (newFilename: string) => { @@ -183,18 +207,75 @@ export function FilePropertiesModal({ Open in New Tab {onFileDelete && fileIndex !== null && ( - +
+ {refs.length > 0 && ( + + + + + + + + + No references found. + + {refs.map((ref) => { + const [refModuleFilePath, modulePath] = + Internal.splitModuleFilePathAndModulePath(ref); + const patchPath = + Internal.createPatchPath(modulePath); + const label = `${prettifyFilename(Internal.splitModuleFilePath(refModuleFilePath).pop() || "")}${modulePath ? ` → ${Internal.splitModulePath(modulePath).join(" → ")}` : ""}`; + const isCurrent = currentSourcePath === ref; + return ( + { + navigate(ref); + setRefsOpen(false); + }} + > + + + + ); + })} + + + + + + )} + +
)} diff --git a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx index e3efa4aeb..aae6b1f63 100644 --- a/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx +++ b/packages/ui/spa/components/FileGallery/stories/FileGallery.stories.tsx @@ -28,6 +28,7 @@ type Story = StoryObj; const imageFiles: GalleryFile[] = [ { + ref: "/images/photos/landscape.jpg", url: "/sample-image-1.jpg", filename: "landscape.jpg", folder: "/images/photos", @@ -40,6 +41,7 @@ const imageFiles: GalleryFile[] = [ createdAt: new Date("2025-12-15T10:30:00"), }, { + ref: "/images/photos/portrait.jpg", url: "/sample-image-2.jpg", filename: "portrait.jpg", folder: "/images/photos", @@ -51,6 +53,7 @@ const imageFiles: GalleryFile[] = [ createdAt: new Date("2025-12-20T14:45:00"), }, { + ref: "/images/banners/wide-shot.jpg", url: "/sample-image-3.jpg", filename: "wide-shot.jpg", folder: "/images/banners", @@ -66,6 +69,7 @@ const imageFiles: GalleryFile[] = [ const mixedFiles: GalleryFile[] = [ ...imageFiles, { + ref: "/videos/demo-video.mp4", url: "/sample-video.mp4", filename: "demo-video.mp4", folder: "/videos", @@ -77,6 +81,7 @@ const mixedFiles: GalleryFile[] = [ createdAt: new Date("2025-11-10T09:00:00"), }, { + ref: "/audio/background-music.mp3", url: "#", filename: "background-music.mp3", folder: "/audio", @@ -88,6 +93,7 @@ const mixedFiles: GalleryFile[] = [ createdAt: new Date("2026-01-05T16:20:00"), }, { + ref: "/data/config.json", url: "#", filename: "config.json", folder: "/data", @@ -99,6 +105,7 @@ const mixedFiles: GalleryFile[] = [ createdAt: new Date("2025-10-01T12:00:00"), }, { + ref: "/docs/readme.txt", url: "#", filename: "readme.txt", folder: "/docs", @@ -110,6 +117,7 @@ const mixedFiles: GalleryFile[] = [ createdAt: new Date("2026-02-01T08:30:00"), }, { + ref: "/downloads/archive.zip", url: "#", filename: "archive.zip", folder: "/downloads", @@ -317,9 +325,11 @@ function generateManyFiles(count: number): GalleryFile[] { return Array.from({ length: count }, (_, i) => { const base = baseFiles[i % baseFiles.length]; + const filename = `${base.filename}-${i + 1}.${base.metadata.mimeType.split("/")[1]}`; return { ...base, - filename: `${base.filename}-${i + 1}.${base.metadata.mimeType.split("/")[1]}`, + ref: `${base.folder}/${filename}`, + filename, createdAt: new Date(Date.now() - i * 1000 * 60 * 60 * 24), }; }); diff --git a/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx b/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx index 48d2b47e7..5db8324c5 100644 --- a/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx +++ b/packages/ui/spa/components/FileGallery/stories/FileProperties.stories.tsx @@ -21,6 +21,7 @@ export default meta; type Story = StoryObj; const sampleImageFile: GalleryFile = { + ref: "/public/val/images/sample-landscape.jpg", url: "/sample-landscape.jpg", filename: "sample-landscape.jpg", folder: "/public/val/images", @@ -34,6 +35,7 @@ const sampleImageFile: GalleryFile = { }; const sampleVideoFile: GalleryFile = { + ref: "/public/val/videos/promotional-video.mp4", url: "/sample-video.mp4", filename: "promotional-video.mp4", folder: "/public/val/videos", @@ -46,6 +48,7 @@ const sampleVideoFile: GalleryFile = { }; const sampleDocumentFile: GalleryFile = { + ref: "/public/val/documents/annual-report-2024.pdf", url: "/document.pdf", filename: "annual-report-2024.pdf", folder: "/public/val/documents", @@ -57,6 +60,7 @@ const sampleDocumentFile: GalleryFile = { }; const fileWithoutAlt: GalleryFile = { + ref: "/public/val/images/no-alt-image.png", url: "/no-alt-image.png", filename: "no-alt-image.png", folder: "/public/val/images", diff --git a/packages/ui/spa/components/FileGallery/types.ts b/packages/ui/spa/components/FileGallery/types.ts index bde0a623e..876d74947 100644 --- a/packages/ui/spa/components/FileGallery/types.ts +++ b/packages/ui/spa/components/FileGallery/types.ts @@ -6,6 +6,7 @@ export interface FileMetadata { } export interface GalleryFile { + ref: string; url: string; filename: string; folder: string; @@ -24,6 +25,7 @@ export type SortDirection = "asc" | "desc"; export interface FileGalleryProps { files: GalleryFile[]; + parentPath?: string; onFileRename?: (index: number, newFilename: string) => void; onAltTextChange?: (index: number, newAltText: string) => void; onFileDelete?: (index: number) => void; diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index 9af4210e6..c08c27215 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -323,30 +323,30 @@ export function FileField({ path }: { path: SourcePath }) { )} {referencedModule && ( - { - addPatch( - [ - { - op: "replace", - path: patchPath, - value: { - [FILE_REF_PROP]: entry.filePath, - [VAL_EXTENSION]: "file", - metadata: entry.metadata as JSONValue, - }, + { + addPatch( + [ + { + op: "replace", + path: patchPath, + value: { + [FILE_REF_PROP]: entry.filePath, + [VAL_EXTENSION]: "file", + metadata: entry.metadata as JSONValue, }, - ], - "file", - ); - }} - isImage={false} - disabled={disabled} - portalContainer={portalContainer} - /> - )} + }, + ], + "file", + ); + }} + isImage={false} + disabled={disabled} + portalContainer={portalContainer} + /> + )}
{source && (showAsVideo ? ( @@ -429,7 +429,7 @@ export function FileField({ path }: { path: SourcePath }) { type, remoteData, moduleDirectory ?? config.files?.directory, - false, + !!referencedModule, ) .then(({ patch, filePath }) => { setLoading(true); diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index 7f29b539b..d84d541fa 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -67,27 +67,26 @@ export function ImageField({ path }: { path: SourcePath }) { sourceAtPath.status === "success" && sourceAtPath.clientSideOnly; useEffect(() => { if (maybeSourceData) { + // We can't set the url before it is server side (since the we will be loading) + if (!maybeClientSideOnly) { + const patchId = filePatchIds.get(maybeSourceData[FILE_REF_PROP]); + const nextUrl = + VAL_EXTENSION in maybeSourceData && + maybeSourceData[VAL_EXTENSION] === "remote" + ? Internal.convertRemoteSource({ + ...maybeSourceData, + [VAL_EXTENSION]: "remote", + ...(patchId ? { patch_id: patchId } : {}), + }).url + : Internal.convertFileSource({ + ...maybeSourceData, + [VAL_EXTENSION]: "file", + ...(patchId ? { patch_id: patchId } : {}), + }).url; + setUrl(nextUrl); + setLoading(false); + } if (maybeSourceData.metadata) { - // We can't set the url before it is server side (since the we will be loading) - if (!maybeClientSideOnly) { - const patchId = filePatchIds.get(maybeSourceData[FILE_REF_PROP]); - const nextUrl = - VAL_EXTENSION in maybeSourceData && - maybeSourceData[VAL_EXTENSION] === "remote" - ? Internal.convertRemoteSource({ - ...maybeSourceData, - [VAL_EXTENSION]: "remote", - ...(patchId ? { patch_id: patchId } : {}), - }).url - : Internal.convertFileSource({ - ...maybeSourceData, - [VAL_EXTENSION]: "file", - ...(patchId ? { patch_id: patchId } : {}), - }).url; - setUrl(nextUrl); - setLoading(false); - } - // const metadata = maybeSourceData.metadata; if ( typeof metadata.width !== "number" || @@ -236,9 +235,9 @@ export function ImageField({ path }: { path: SourcePath }) {
)}
- {source && ( + {source && !moduleDirectory && (
- Alt text + Description { setLoading(true); @@ -464,31 +463,32 @@ export function ImageField({ path }: { path: SourcePath }) { .then(() => { if ( !hasError && - referencedModule && filePath && metadata?.mimeType && metadata.width !== undefined && metadata.height !== undefined ) { - addModuleFilePatch( - referencedModule as ModuleFilePath, - [ - { - op: "add", - path: [filePath], - value: { - width: metadata.width, - height: metadata.height, - mimeType: metadata.mimeType, - alt: - typeof metadata.alt === "string" - ? metadata.alt - : null, - } as JSONValue, - }, - ], - "record", - ); + if (referencedModule) { + addModuleFilePatch( + referencedModule as ModuleFilePath, + [ + { + op: "add", + path: [filePath], + value: { + width: metadata.width, + height: metadata.height, + mimeType: metadata.mimeType, + alt: + typeof metadata.alt === "string" + ? metadata.alt + : null, + } as JSONValue, + }, + ], + "record", + ); + } } }) .finally(() => { diff --git a/packages/ui/spa/components/fields/ModuleGallery.tsx b/packages/ui/spa/components/fields/ModuleGallery.tsx index 6f28677a2..6f3f996e8 100644 --- a/packages/ui/spa/components/fields/ModuleGallery.tsx +++ b/packages/ui/spa/components/fields/ModuleGallery.tsx @@ -38,6 +38,7 @@ function refToUrl( } export function ModuleGallery({ path }: { path: SourcePath }) { + const [moduleFilePath] = Internal.splitModuleFilePathAndModulePath(path); const source = useSourceAtPath(path); const schemaAtPath = useSchemaAtPath(path); const filePatchIds = useFilePatchIds(); @@ -84,6 +85,7 @@ export function ModuleGallery({ path }: { path: SourcePath }) { } return { + ref, url: refToUrl(ref, filePatchIds), filename: ref.split("/").pop() || ref, folder: ref.substring(0, ref.lastIndexOf("/")), @@ -267,6 +269,7 @@ export function ModuleGallery({ path }: { path: SourcePath }) { /> , + sources: Record, + parent: ModuleFilePath, + fileRef?: string, // if provided, filter to only paths whose source has _ref === fileRef +): SourcePath[] { + const results: SourcePath[] = []; + const go = ( + sourcePath: SourcePath, + schema: SerializedSchema | undefined, + source: Source, + ) => { + if (schema === undefined) { + console.error(`Schema not found for ${sourcePath}`); + return; + } + if ( + (schema.type === "image" || schema.type === "file") && + schema.referencedModule === parent + ) { + if (fileRef !== undefined) { + if ( + typeof source === "object" && + source !== null && + !Array.isArray(source) && + FILE_REF_PROP in source && + (source as Record)[FILE_REF_PROP] === fileRef + ) { + if (!results.includes(sourcePath)) { + results.push(sourcePath); + } + } + } else { + if (!results.includes(sourcePath)) { + results.push(sourcePath); + } + } + } else if (schema.type === "object" || schema.type === "record") { + if (isObjectSource(source) || isRecordSource(source)) { + for (const key in source) { + const sourceValue = (source as Record)[key]; + const schemaValue = + schema.type === "object" ? schema.items?.[key] : schema.item; + if (sourceValue) { + go(sourcePathConcat(sourcePath, key), schemaValue, sourceValue); + } + } + } + } else if (schema.type === "array") { + if (isArrayOfSource(source)) { + let i = 0; + for (const sourceValue of source) { + go(sourcePathConcat(sourcePath, i), schema.item, sourceValue); + i++; + } + } + } else if (schema.type === "union") { + // ignore string unions + const schemaKey = schema.key; + if (typeof schemaKey === "string") { + if (isObjectSource(source)) { + const itemKey = (source as Record)[schemaKey]; + if (typeof itemKey === "string") { + const schemaOfItem = (schema.items as SerializedObjectSchema[]) + .filter((item) => item.type === "object") + .find((item) => { + const itemKeySchema = item.items[schemaKey]; + if (itemKeySchema?.type === "literal") { + return itemKeySchema.value === itemKey; + } + }); + if (schemaOfItem) { + go(sourcePath, schemaOfItem, source); + } + } + } + } + } else if ( + schema.type === "string" || + schema.type === "number" || + schema.type === "boolean" || + schema.type === "literal" || + schema.type === "date" || + schema.type === "keyOf" || + schema.type === "image" || + schema.type === "file" || + schema.type === "richtext" || + schema.type === "route" + ) { + // ignore these + } else { + const exhaustiveCheck: never = schema; + console.error( + `Could not get referenced files. Unhandled schema type`, + exhaustiveCheck, + ); + } + }; + for (const moduleFilePathS in schemas) { + const moduleFilePath = moduleFilePathS as ModuleFilePath; + go( + moduleFilePathS as SourcePath, + schemas[moduleFilePath], + sources[moduleFilePath], + ); + } + return results; +} + +function sourcePathConcat( + sourcePath: SourcePath, + key: string | number, +): SourcePath { + if (sourcePath.includes(ModuleFilePathSep)) { + return `${sourcePath}.${JSON.stringify(key)}` as SourcePath; + } + return `${sourcePath}${ModuleFilePathSep}${JSON.stringify( + key, + )}` as SourcePath; +} + +function isObjectSource(source: Source): source is Record { + return isRecordSource(source); +} + +function isRecordSource(source: Source): source is Record { + return typeof source === "object" && !!source && !Array.isArray(source); +} + +function isArrayOfSource(source: Source): source is Json[] { + return typeof source === "object" && !!source && Array.isArray(source); +} diff --git a/packages/ui/spa/components/useKeysOf.ts b/packages/ui/spa/components/useKeysOf.ts index e4fd9c047..36446b6e4 100644 --- a/packages/ui/spa/components/useKeysOf.ts +++ b/packages/ui/spa/components/useKeysOf.ts @@ -21,6 +21,7 @@ export function useKeysOf( schemas.data !== undefined && schemas.data[parentPath] !== undefined ) { + console.log(getKeysOf(schemas.data, allSources, parentPath, keyValue)); return getKeysOf(schemas.data, allSources, parentPath, keyValue); } return []; diff --git a/packages/ui/spa/components/useReferencedFiles.ts b/packages/ui/spa/components/useReferencedFiles.ts new file mode 100644 index 000000000..e813e4174 --- /dev/null +++ b/packages/ui/spa/components/useReferencedFiles.ts @@ -0,0 +1,34 @@ +import { ModuleFilePath } from "@valbuild/core"; +import { useMemo } from "react"; +import { + useAllSources, + useSchemas, + useLoadingStatus, +} from "./ValFieldProvider"; +import { getReferencedFiles } from "./getReferencedFiles"; + +export function useReferencedFiles( + parentPath: ModuleFilePath | undefined, + keyValue?: string, +) { + const schemas = useSchemas(); + const loadingStatus = useLoadingStatus(); + const allSources = useAllSources(); + const referencingModuleFilePaths = useMemo(() => { + if ( + parentPath !== undefined && + "data" in schemas && + schemas.data !== undefined + ) { + return getReferencedFiles(schemas.data, allSources, parentPath, keyValue); + } + return []; + }, [ + loadingStatus, + allSources, + "data" in schemas && schemas.data, + parentPath, + keyValue, + ]); + return referencingModuleFilePaths; +} From c739e6afe8c01190a218c7a5b69d23c16e2c7e19 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 5 Mar 2026 17:51:31 +0000 Subject: [PATCH 25/32] Refactor keys of and referenced files --- packages/ui/spa/components/getKeysOf.ts | 96 +------ .../spa/components/getReferencedFiles.test.ts | 255 ++++++++++++++++++ .../ui/spa/components/getReferencedFiles.ts | 87 +----- packages/ui/spa/components/traverseSchemas.ts | 115 ++++++++ 4 files changed, 377 insertions(+), 176 deletions(-) create mode 100644 packages/ui/spa/components/getReferencedFiles.test.ts create mode 100644 packages/ui/spa/components/traverseSchemas.ts diff --git a/packages/ui/spa/components/getKeysOf.ts b/packages/ui/spa/components/getKeysOf.ts index fd7128f31..7e4855977 100644 --- a/packages/ui/spa/components/getKeysOf.ts +++ b/packages/ui/spa/components/getKeysOf.ts @@ -1,12 +1,5 @@ -import { - Json, - ModuleFilePath, - ModuleFilePathSep, - Source, - SerializedObjectSchema, - SerializedSchema, - SourcePath, -} from "@valbuild/core"; +import { ModuleFilePath, SerializedSchema, Source, SourcePath } from "@valbuild/core"; +import { traverseSchemas } from "./traverseSchemas"; // TODO: right now we only support keyOf MODULES that are records // We are planning to add support for keyOf selectors (i.e. nested properties of modules) that are records @@ -29,15 +22,7 @@ export function getKeysOf( } const parentSourcePath = parent as unknown as SourcePath; const results: SourcePath[] = []; - const go = ( - sourcePath: SourcePath, - schema: SerializedSchema | undefined, - source: Source, - ) => { - if (schema === undefined) { - console.error(`Schema not found for ${sourcePath}`); - return; - } + traverseSchemas(schemas, sources, (sourcePath, schema, source) => { if (schema.type === "keyOf") { if (schema.path === parentSourcePath) { if (keyOfRecord) { @@ -60,47 +45,6 @@ export function getKeysOf( } } } - } else if (schema.type === "object" || schema.type === "record") { - if (isObjectSource(source) || isRecordSource(source)) { - for (const key in source) { - // NOTE: for object we are uncertain if we should use the source or the schema to get the keys. Currently we use the schema.items in other places, but source is more correct perhaps? Or perhaps not? We are not sure... - const sourceValue = (source as Record)[key]; - const schemaValue = - schema.type === "object" ? schema.items?.[key] : schema.item; - if (sourceValue) { - go(sourcePathConcat(sourcePath, key), schemaValue, sourceValue); - } - } - } - } else if (schema.type === "array") { - if (isArrayOfSource(source)) { - let i = 0; - for (const sourceValue of source) { - go(sourcePathConcat(sourcePath, i), schema.item, sourceValue); - i++; - } - } - } else if (schema.type === "union") { - // ignore string unions - const schemaKey = schema.key; - if (typeof schemaKey === "string") { - if (isObjectSource(source)) { - const itemKey = (source as Record)[schemaKey]; - if (typeof itemKey === "string") { - const schemaOfItem = (schema.items as SerializedObjectSchema[]) - .filter((item) => item.type === "object") - .find((item) => { - const itemKeySchema = item.items[schemaKey]; - if (itemKeySchema?.type === "literal") { - return itemKeySchema.value === itemKey; - } - }); - if (schemaOfItem) { - go(sourcePath, schemaOfItem, source); - } - } - } - } } else if ( schema.type === "string" || schema.type === "number" || @@ -120,38 +64,6 @@ export function getKeysOf( exhaustiveCheck, ); } - }; - for (const moduleFilePathS in schemas) { - const moduleFilePath = moduleFilePathS as ModuleFilePath; - go( - moduleFilePathS as SourcePath, - schemas[moduleFilePath], - sources[moduleFilePath], - ); - } + }); return results; } - -function sourcePathConcat( - sourcePath: SourcePath, - key: string | number, -): SourcePath { - if (sourcePath.includes(ModuleFilePathSep)) { - return `${sourcePath}.${JSON.stringify(key)}` as SourcePath; - } - return `${sourcePath}${ModuleFilePathSep}${JSON.stringify( - key, - )}` as SourcePath; -} - -function isObjectSource(source: Source): source is Record { - return isRecordSource(source); -} - -function isRecordSource(source: Source): source is Record { - return typeof source === "object" && !!source && !Array.isArray(source); -} - -function isArrayOfSource(source: Source): source is Json[] { - return typeof source === "object" && !!source && Array.isArray(source); -} diff --git a/packages/ui/spa/components/getReferencedFiles.test.ts b/packages/ui/spa/components/getReferencedFiles.test.ts new file mode 100644 index 000000000..2b97831e2 --- /dev/null +++ b/packages/ui/spa/components/getReferencedFiles.test.ts @@ -0,0 +1,255 @@ +import { + Internal, + ModuleFilePath, + SerializedSchema, + Source, + ValModule, + initVal, +} from "@valbuild/core"; +import { getReferencedFiles } from "./getReferencedFiles"; + +const { s, c } = initVal(); + +describe("getReferencedFiles", () => { + test("find image field referencing module", () => { + const imagesModule = c.define( + "/images.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + { + "/public/val/img.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: null, + }, + }, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ img: s.image(imagesModule) }), + { + img: c.image("/public/val/img.png", { + width: 100, + height: 100, + mimeType: "image/png", + }), + }, + ); + const { schemas, sources } = getTestData([imagesModule, pageModule]); + const result = getReferencedFiles( + schemas, + sources, + "/images.val.ts" as ModuleFilePath, + ); + expect(result).toEqual(['/page.val.ts?p="img"']); + }); + + test("filter by fileRef (match)", () => { + const imagesModule = c.define( + "/images.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + { + "/public/val/img.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: null, + }, + }, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ img: s.image(imagesModule) }), + { + img: c.image("/public/val/img.png", { + width: 100, + height: 100, + mimeType: "image/png", + }), + }, + ); + const { schemas, sources } = getTestData([imagesModule, pageModule]); + const result = getReferencedFiles( + schemas, + sources, + "/images.val.ts" as ModuleFilePath, + "/public/val/img.png", + ); + expect(result).toEqual(['/page.val.ts?p="img"']); + }); + + test("filter by fileRef (no match)", () => { + const imagesModule = c.define( + "/images.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + { + "/public/val/img.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: null, + }, + }, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ img: s.image(imagesModule) }), + { + img: c.image("/public/val/img.png", { + width: 100, + height: 100, + mimeType: "image/png", + }), + }, + ); + const { schemas, sources } = getTestData([imagesModule, pageModule]); + const result = getReferencedFiles( + schemas, + sources, + "/images.val.ts" as ModuleFilePath, + "/public/val/other.png", + ); + expect(result).toEqual([]); + }); + + test("no match when different module", () => { + const imagesModule1 = c.define( + "/images1.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + {}, + ); + const imagesModule2 = c.define( + "/images2.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + {}, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ img: s.image(imagesModule1) }), + { + img: c.image("/public/val/img.png", { + width: 100, + height: 100, + mimeType: "image/png", + }), + }, + ); + const { schemas, sources } = getTestData([ + imagesModule1, + imagesModule2, + pageModule, + ]); + const result = getReferencedFiles( + schemas, + sources, + "/images2.val.ts" as ModuleFilePath, + ); + expect(result).toEqual([]); + }); + + test("find file field referencing module", () => { + const filesModule = c.define( + "/files.val.ts", + s.files({ accept: "*/*", directory: "/public/val" }), + { + "/public/val/doc.pdf": { + mimeType: "application/pdf", + }, + }, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ doc: s.file(filesModule) }), + { + doc: c.file("/public/val/doc.pdf", { mimeType: "application/pdf" }), + }, + ); + const { schemas, sources } = getTestData([filesModule, pageModule]); + const result = getReferencedFiles( + schemas, + sources, + "/files.val.ts" as ModuleFilePath, + ); + expect(result).toEqual(['/page.val.ts?p="doc"']); + }); + + test("find nested image field", () => { + const imagesModule = c.define( + "/images.val.ts", + s.images({ accept: "image/*", directory: "/public/val" }), + { + "/public/val/img.png": { + width: 100, + height: 100, + mimeType: "image/png", + alt: null, + }, + }, + ); + const pageModule = c.define( + "/page.val.ts", + s.object({ + section: s.object({ + items: s.array( + s.object({ + img: s.image(imagesModule), + }), + ), + }), + }), + { + section: { + items: [ + { + img: c.image("/public/val/img.png", { + width: 100, + height: 100, + mimeType: "image/png", + }), + }, + ], + }, + }, + ); + const { schemas, sources } = getTestData([imagesModule, pageModule]); + const result = getReferencedFiles( + schemas, + sources, + "/images.val.ts" as ModuleFilePath, + ); + expect(result).toEqual([ + '/page.val.ts?p="section"."items".0."img"', + ]); + }); +}); + +function getTestData(valModules: ValModule[]) { + const schemas: Record = {}; + const sources: Record = {}; + for (const valModule of valModules) { + const moduleFilePath = getModuleFilePath(valModule); + schemas[moduleFilePath] = getSchema(valModule); + sources[moduleFilePath] = getSource(valModule); + } + return { schemas, sources }; +} + +function getModuleFilePath(valModule: ValModule): ModuleFilePath { + return Internal.getValPath(valModule) as unknown as ModuleFilePath; +} + +function getSchema(valModule: ValModule): SerializedSchema { + const schema = Internal.getSchema(valModule)?.["executeSerialize"](); + if (!schema) { + throw new Error("Schema not found"); + } + return schema; +} + +function getSource(valModule: ValModule): Source { + const source = Internal.getSource(valModule); + if (!source) { + throw new Error("Source not found"); + } + return source; +} diff --git a/packages/ui/spa/components/getReferencedFiles.ts b/packages/ui/spa/components/getReferencedFiles.ts index 5ecbcfc70..01529e949 100644 --- a/packages/ui/spa/components/getReferencedFiles.ts +++ b/packages/ui/spa/components/getReferencedFiles.ts @@ -2,12 +2,11 @@ import { FILE_REF_PROP, Json, ModuleFilePath, - ModuleFilePathSep, - SerializedObjectSchema, SerializedSchema, Source, SourcePath, } from "@valbuild/core"; +import { traverseSchemas } from "./traverseSchemas"; export function getReferencedFiles( schemas: Record, @@ -16,15 +15,7 @@ export function getReferencedFiles( fileRef?: string, // if provided, filter to only paths whose source has _ref === fileRef ): SourcePath[] { const results: SourcePath[] = []; - const go = ( - sourcePath: SourcePath, - schema: SerializedSchema | undefined, - source: Source, - ) => { - if (schema === undefined) { - console.error(`Schema not found for ${sourcePath}`); - return; - } + traverseSchemas(schemas, sources, (sourcePath, schema, source) => { if ( (schema.type === "image" || schema.type === "file") && schema.referencedModule === parent @@ -46,46 +37,6 @@ export function getReferencedFiles( results.push(sourcePath); } } - } else if (schema.type === "object" || schema.type === "record") { - if (isObjectSource(source) || isRecordSource(source)) { - for (const key in source) { - const sourceValue = (source as Record)[key]; - const schemaValue = - schema.type === "object" ? schema.items?.[key] : schema.item; - if (sourceValue) { - go(sourcePathConcat(sourcePath, key), schemaValue, sourceValue); - } - } - } - } else if (schema.type === "array") { - if (isArrayOfSource(source)) { - let i = 0; - for (const sourceValue of source) { - go(sourcePathConcat(sourcePath, i), schema.item, sourceValue); - i++; - } - } - } else if (schema.type === "union") { - // ignore string unions - const schemaKey = schema.key; - if (typeof schemaKey === "string") { - if (isObjectSource(source)) { - const itemKey = (source as Record)[schemaKey]; - if (typeof itemKey === "string") { - const schemaOfItem = (schema.items as SerializedObjectSchema[]) - .filter((item) => item.type === "object") - .find((item) => { - const itemKeySchema = item.items[schemaKey]; - if (itemKeySchema?.type === "literal") { - return itemKeySchema.value === itemKey; - } - }); - if (schemaOfItem) { - go(sourcePath, schemaOfItem, source); - } - } - } - } } else if ( schema.type === "string" || schema.type === "number" || @@ -106,38 +57,6 @@ export function getReferencedFiles( exhaustiveCheck, ); } - }; - for (const moduleFilePathS in schemas) { - const moduleFilePath = moduleFilePathS as ModuleFilePath; - go( - moduleFilePathS as SourcePath, - schemas[moduleFilePath], - sources[moduleFilePath], - ); - } + }); return results; } - -function sourcePathConcat( - sourcePath: SourcePath, - key: string | number, -): SourcePath { - if (sourcePath.includes(ModuleFilePathSep)) { - return `${sourcePath}.${JSON.stringify(key)}` as SourcePath; - } - return `${sourcePath}${ModuleFilePathSep}${JSON.stringify( - key, - )}` as SourcePath; -} - -function isObjectSource(source: Source): source is Record { - return isRecordSource(source); -} - -function isRecordSource(source: Source): source is Record { - return typeof source === "object" && !!source && !Array.isArray(source); -} - -function isArrayOfSource(source: Source): source is Json[] { - return typeof source === "object" && !!source && Array.isArray(source); -} diff --git a/packages/ui/spa/components/traverseSchemas.ts b/packages/ui/spa/components/traverseSchemas.ts new file mode 100644 index 000000000..ec16dd597 --- /dev/null +++ b/packages/ui/spa/components/traverseSchemas.ts @@ -0,0 +1,115 @@ +import { + Json, + ModuleFilePath, + ModuleFilePathSep, + SerializedArraySchema, + SerializedObjectSchema, + SerializedRecordSchema, + SerializedSchema, + SerializedUnionSchema, + Source, + SourcePath, +} from "@valbuild/core"; + +export type LeafSerializedSchema = Exclude< + SerializedSchema, + | SerializedObjectSchema + | SerializedArraySchema + | SerializedUnionSchema + | SerializedRecordSchema +>; + +export type LeafVisitor = ( + sourcePath: SourcePath, + schema: LeafSerializedSchema, + source: Source, +) => void; + +export function traverseSchemas( + schemas: Record, + sources: Record, + visit: LeafVisitor, +): void { + const go = ( + sourcePath: SourcePath, + schema: SerializedSchema | undefined, + source: Source, + ) => { + if (schema === undefined) { + console.error(`Schema not found for ${sourcePath}`); + return; + } + if (schema.type === "object" || schema.type === "record") { + if (isObjectOrRecordSource(source)) { + for (const key in source) { + // NOTE: for object we are uncertain if we should use the source or the schema to get the keys. Currently we use the schema.items in other places, but source is more correct perhaps? Or perhaps not? We are not sure... + const sourceValue = (source as Record)[key]; + const schemaValue = + schema.type === "object" ? schema.items?.[key] : schema.item; + if (sourceValue) { + go(sourcePathConcat(sourcePath, key), schemaValue, sourceValue); + } + } + } + } else if (schema.type === "array") { + if (isArraySource(source)) { + let i = 0; + for (const sourceValue of source) { + go(sourcePathConcat(sourcePath, i), schema.item, sourceValue); + i++; + } + } + } else if (schema.type === "union") { + // ignore string unions + const schemaKey = schema.key; + if (typeof schemaKey === "string") { + if (isObjectOrRecordSource(source)) { + const itemKey = (source as Record)[schemaKey]; + if (typeof itemKey === "string") { + const schemaOfItem = (schema.items as SerializedObjectSchema[]) + .filter((item) => item.type === "object") + .find((item) => { + const itemKeySchema = item.items[schemaKey]; + if (itemKeySchema?.type === "literal") { + return itemKeySchema.value === itemKey; + } + }); + if (schemaOfItem) { + go(sourcePath, schemaOfItem, source); + } + } + } + } + } else { + visit(sourcePath, schema as LeafSerializedSchema, source); + } + }; + for (const moduleFilePathS in schemas) { + const moduleFilePath = moduleFilePathS as ModuleFilePath; + go( + moduleFilePathS as SourcePath, + schemas[moduleFilePath], + sources[moduleFilePath], + ); + } +} + +export function sourcePathConcat( + sourcePath: SourcePath, + key: string | number, +): SourcePath { + if (sourcePath.includes(ModuleFilePathSep)) { + return `${sourcePath}.${JSON.stringify(key)}` as SourcePath; + } + return `${sourcePath}${ModuleFilePathSep}${JSON.stringify( + key, + )}` as SourcePath; +} + +function isObjectOrRecordSource(source: Source): source is Record { + return typeof source === "object" && !!source && !Array.isArray(source); +} + +function isArraySource(source: Source): source is Json[] { + return typeof source === "object" && !!source && Array.isArray(source); +} From 687248438053cd2212318be26b24ac7469723168 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 5 Mar 2026 17:52:06 +0000 Subject: [PATCH 26/32] Use referenced files in FilePropertiesModal --- .../ui/spa/components/FileGallery/FilePropertiesModal.tsx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx index 6a69ab8b3..1ed41ee7e 100644 --- a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -13,7 +13,7 @@ import { FilePreview } from "./FilePreview"; import { FilenameInput } from "./FilenameInput"; import type { GalleryFile } from "./types"; import { FieldValidationError } from "../FieldValidationError"; -import { useKeysOf } from "../useKeysOf"; +import { useReferencedFiles } from "../useReferencedFiles"; import { useNavigation } from "../ValRouter"; import { ValPath } from "../ValPath"; import { prettifyFilename } from "../../utils/prettifyFilename"; @@ -60,7 +60,7 @@ export function FilePropertiesModal({ disabled, container, }: FilePropertiesModalProps) { - const refs = useKeysOf(parentPath as ModuleFilePath | undefined, file?.ref); + const refs = useReferencedFiles(parentPath as ModuleFilePath | undefined, file?.ref); const { navigate, currentSourcePath } = useNavigation(); const [refsOpen, setRefsOpen] = React.useState(false); From e70dea7a31cf36a7284c1cb8f182c62a053ffd5a Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 5 Mar 2026 18:20:33 +0000 Subject: [PATCH 27/32] Show tooltip if delete file is disabled --- .../FileGallery/FilePropertiesModal.tsx | 44 ++++++++++++++----- 1 file changed, 32 insertions(+), 12 deletions(-) diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx index 1ed41ee7e..ccdbf109b 100644 --- a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -14,6 +14,12 @@ import { FilenameInput } from "./FilenameInput"; import type { GalleryFile } from "./types"; import { FieldValidationError } from "../FieldValidationError"; import { useReferencedFiles } from "../useReferencedFiles"; +import { + Tooltip, + TooltipContent, + TooltipProvider, + TooltipTrigger, +} from "../designSystem/tooltip"; import { useNavigation } from "../ValRouter"; import { ValPath } from "../ValPath"; import { prettifyFilename } from "../../utils/prettifyFilename"; @@ -263,18 +269,32 @@ export function FilePropertiesModal({ )} - + + + + + + + + {refs.length > 0 && ( + + Cannot delete: referenced in {refs.length}{" "} + {refs.length === 1 ? "place" : "places"} + + )} + +
)}
From 5c5986d131701453a641ea2862c754caa2d6d625 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 5 Mar 2026 21:47:46 +0100 Subject: [PATCH 28/32] Remove unsightly border in explorer --- packages/ui/spa/components/NavMenu/ExplorerSection.tsx | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/ui/spa/components/NavMenu/ExplorerSection.tsx b/packages/ui/spa/components/NavMenu/ExplorerSection.tsx index 0b375a15d..e323262d0 100644 --- a/packages/ui/spa/components/NavMenu/ExplorerSection.tsx +++ b/packages/ui/spa/components/NavMenu/ExplorerSection.tsx @@ -27,7 +27,7 @@ export function ExplorerSection({ maxHeight = "100%", }: ExplorerSectionProps) { return ( - + Date: Sat, 7 Mar 2026 17:38:47 +0100 Subject: [PATCH 29/32] Improve validation testability --- .../__fixtures__/basic/content/test.val.ts | 5 + .../cli/src/__fixtures__/basic/tsconfig.json | 12 + packages/cli/src/runValidation.test.ts | 41 + packages/cli/src/runValidation.ts | 972 ++++++++++++++++ packages/cli/src/validate.ts | 1007 ++--------------- packages/server/src/Service.ts | 7 + packages/server/src/ValFS.ts | 2 + packages/server/src/ValFSHost.ts | 5 + packages/server/src/ValModuleLoader.ts | 14 + packages/server/src/ValSourceFileHandler.ts | 7 + 10 files changed, 1185 insertions(+), 887 deletions(-) create mode 100644 packages/cli/src/__fixtures__/basic/content/test.val.ts create mode 100644 packages/cli/src/__fixtures__/basic/tsconfig.json create mode 100644 packages/cli/src/runValidation.test.ts create mode 100644 packages/cli/src/runValidation.ts diff --git a/packages/cli/src/__fixtures__/basic/content/test.val.ts b/packages/cli/src/__fixtures__/basic/content/test.val.ts new file mode 100644 index 000000000..131f094b9 --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/content/test.val.ts @@ -0,0 +1,5 @@ +import { initVal } from "@valbuild/core"; + +const { s, c } = initVal(); + +export default c.define("/content/test.val.ts", s.string(), "Hello World"); diff --git a/packages/cli/src/__fixtures__/basic/tsconfig.json b/packages/cli/src/__fixtures__/basic/tsconfig.json new file mode 100644 index 000000000..110571d10 --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/tsconfig.json @@ -0,0 +1,12 @@ +{ + "compilerOptions": { + "target": "es5", + "allowJs": true, + "skipLibCheck": true, + "strict": true, + "esModuleInterop": true, + "module": "esnext", + "moduleResolution": "node" + }, + "exclude": ["node_modules"] +} diff --git a/packages/cli/src/runValidation.test.ts b/packages/cli/src/runValidation.test.ts new file mode 100644 index 000000000..7775948e9 --- /dev/null +++ b/packages/cli/src/runValidation.test.ts @@ -0,0 +1,41 @@ +import { describe, test, expect } from "@jest/globals"; +import path from "path"; +import { DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core"; +import { + createDefaultValFSHost, + runValidation, + ValidationEvent, + IValRemote, +} from "./runValidation"; + +const BASIC_FIXTURE = path.resolve(__dirname, "__fixtures__/basic"); + +const mockRemote: IValRemote = { + remoteHost: DEFAULT_VAL_REMOTE_HOST, + getSettings: async () => { + throw new Error("Not expected to be called"); + }, + uploadFile: async () => { + throw new Error("Not expected to be called"); + }, +}; + +describe("runValidation", () => { + test("returns summary-success for a valid module", async () => { + const events: ValidationEvent[] = []; + + for await (const event of runValidation({ + root: BASIC_FIXTURE, + fix: false, + valFiles: ["content/test.val.ts"], + project: undefined, + remote: mockRemote, + fs: createDefaultValFSHost(), + })) { + events.push(event); + } + + expect(events.at(-1)).toEqual({ type: "summary-success" }); + expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0); + }); +}); diff --git a/packages/cli/src/runValidation.ts b/packages/cli/src/runValidation.ts new file mode 100644 index 000000000..84bc1a60f --- /dev/null +++ b/packages/cli/src/runValidation.ts @@ -0,0 +1,972 @@ +import path from "path"; +import { + createFixPatch, + createService, + getPersonalAccessTokenPath, + parsePersonalAccessTokenFile, + Service, + IValFSHost, +} from "@valbuild/server"; +import { + FILE_REF_PROP, + Internal, + ModuleFilePath, + ModulePath, + SerializedFileSchema, + SerializedImageSchema, + SourcePath, + ValidationFix, +} from "@valbuild/core"; +import { + filterRoutesByPatterns, + validateRoutePatterns, + type SerializedRegExpPattern, +} from "@valbuild/shared/internal"; +import { getFileExt } from "./utils/getFileExt"; +import ts from "typescript"; +import nodeFs from "fs"; + +export type { IValFSHost }; + +export type IValRemote = { + remoteHost: string; + getSettings( + projectName: string, + options: { pat: string }, + ): Promise< + | { + success: true; + data: { + publicProjectId: string; + remoteFileBuckets: { bucket: string }[]; + }; + } + | { success: false; message: string } + >; + uploadFile( + project: string, + bucket: string, + fileHash: string, + fileExt: string | undefined, + fileBuffer: Buffer, + options: { pat: string }, + ): Promise<{ success: true } | { success: false; error: string }>; +}; + +const textEncoder = new TextEncoder(); + +// Types for handler system +export type ValModule = Awaited>; + +export type ValidationError = { + message: string; + value?: unknown; + fixes?: ValidationFix[]; +}; + +// Cache types for avoiding redundant service.get() calls +export type KeyOfCache = Map< + string, // moduleFilePath + modulePath key + { source: unknown; schema: { type: string } | undefined } +>; +export type RouterModulesCache = { + loaded: boolean; + modules: Record>; +}; + +export type FixHandlerContext = { + sourcePath: SourcePath; + validationError: ValidationError; + valModule: ValModule; + projectRoot: string; + fix: boolean; + service: Service; + valFiles: string[]; + moduleFilePath: ModuleFilePath; + file: string; + fs: IValFSHost; + // Shared state + remoteFiles: Record< + SourcePath, + { ref: string; metadata?: Record } + >; + publicProjectId?: string; + remoteFileBuckets?: string[]; + remoteFilesCounter: number; + remote: IValRemote; + project: string | undefined; + // Caches for validation + keyOfCache: KeyOfCache; + routerModulesCache: RouterModulesCache; +}; + +export type FixHandlerResult = { + success: boolean; + errorMessage?: string; + shouldApplyPatch?: boolean; + // Updated shared state + publicProjectId?: string; + remoteFileBuckets?: string[]; + remoteFilesCounter?: number; + // Events to emit + events?: ValidationEvent[]; +}; + +export type FixHandler = (ctx: FixHandlerContext) => Promise; + +export type ValidationEvent = + | { type: "file-valid"; file: string; durationMs: number } + | { + type: "file-error-count"; + file: string; + errorCount: number; + durationMs: number; + } + | { type: "validation-error"; sourcePath: string; message: string } + | { + type: "validation-fixable-error"; + sourcePath: string; + message: string; + fixable: boolean; + } + | { type: "unknown-fix"; sourcePath: string; fixes: string[] } + | { type: "fix-applied"; file: string; sourcePath: string } + | { type: "fatal-error"; file: string; message: string } + | { type: "remote-uploading"; ref: string } + | { type: "remote-uploaded"; ref: string } + | { type: "remote-already-uploaded"; filePath: string } + | { type: "remote-downloading"; sourcePath: string } + | { type: "summary-errors"; count: number } + | { type: "summary-success" }; + +// Handler functions +export async function handleFileMetadata( + ctx: FixHandlerContext, +): Promise { + const [, modulePath] = Internal.splitModuleFilePathAndModulePath( + ctx.sourcePath, + ); + + if (!ctx.valModule.source || !ctx.valModule.schema) { + return { + success: false, + errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`, + }; + } + + const fileSource = Internal.resolvePath( + modulePath, + ctx.valModule.source, + ctx.valModule.schema, + ); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const fileRefProp = (fileSource.source as any)?.[FILE_REF_PROP]; + if (!fileRefProp) { + return { + success: false, + errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`, + }; + } + + const filePath = path.join(ctx.projectRoot, fileRefProp); + if (!ctx.fs.fileExists(filePath)) { + return { + success: false, + errorMessage: `File ${filePath} does not exist`, + }; + } + + return { success: true, shouldApplyPatch: true }; +} + +export async function handleKeyOfCheck( + ctx: FixHandlerContext, +): Promise { + if ( + !ctx.validationError.value || + typeof ctx.validationError.value !== "object" || + !("key" in ctx.validationError.value) || + !("sourcePath" in ctx.validationError.value) + ) { + return { + success: false, + errorMessage: `Unexpected error in ${ctx.sourcePath}: ${ctx.validationError.message} (Expected value to be an object with 'key' and 'sourcePath' properties - this is likely a bug in Val)`, + }; + } + + const { key, sourcePath } = ctx.validationError.value as { + key: unknown; + sourcePath: unknown; + }; + + if (typeof key !== "string") { + return { + success: false, + errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'key' to be a string - this is likely a bug in Val)`, + }; + } + + if (typeof sourcePath !== "string") { + return { + success: false, + errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'sourcePath' to be a string - this is likely a bug in Val)`, + }; + } + + const res = await checkKeyIsValid( + key, + sourcePath, + ctx.service, + ctx.keyOfCache, + ); + if (res.error) { + return { + success: false, + errorMessage: res.message, + }; + } + + return { success: true }; +} + +export async function handleRemoteFileUpload( + ctx: FixHandlerContext, +): Promise { + if (!ctx.fix) { + return { + success: false, + errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`, + }; + } + + const [, modulePath] = Internal.splitModuleFilePathAndModulePath( + ctx.sourcePath, + ); + + if (!ctx.valModule.source || !ctx.valModule.schema) { + return { + success: false, + errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`, + }; + } + + const resolvedRemoteFileAtSourcePath = Internal.resolvePath( + modulePath, + ctx.valModule.source, + ctx.valModule.schema, + ); + + // eslint-disable-next-line @typescript-eslint/no-explicit-any + const fileRefProp = (resolvedRemoteFileAtSourcePath.source as any)?.[ + FILE_REF_PROP + ]; + if (!fileRefProp) { + return { + success: false, + errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`, + }; + } + + const filePath = path.join(ctx.projectRoot, fileRefProp); + if (!ctx.fs.fileExists(filePath)) { + return { + success: false, + errorMessage: `File ${filePath} does not exist`, + }; + } + + const patFile = getPersonalAccessTokenPath(ctx.projectRoot); + if (!ctx.fs.fileExists(patFile)) { + return { + success: false, + errorMessage: `File: ${path.join(ctx.projectRoot, ctx.file)} has remote images that are not uploaded and you are not logged in.\n\nFix this error by logging in:\n\t"npx val login"\n`, + }; + } + + const patFileContent = ctx.fs.readFile(patFile); + if (patFileContent === undefined) { + return { + success: false, + errorMessage: `Could not read personal access token file at ${patFile}`, + }; + } + + const parsedPatFile = parsePersonalAccessTokenFile(patFileContent); + if (!parsedPatFile.success) { + return { + success: false, + errorMessage: `Error parsing personal access token file: ${parsedPatFile.error}. You need to login again.`, + }; + } + const { pat } = parsedPatFile.data; + + if (ctx.remoteFiles[ctx.sourcePath]) { + return { + success: true, + events: [{ type: "remote-already-uploaded", filePath }], + }; + } + + if (!resolvedRemoteFileAtSourcePath.schema) { + return { + success: false, + errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`, + }; + } + + const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source; + const fileSourceMetadata = Internal.isFile(actualRemoteFileSource) + ? actualRemoteFileSource.metadata + : undefined; + const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema; + + if (!resolveRemoteFileSchema) { + return { + success: false, + errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`, + }; + } + + const projectName = ctx.project; + let publicProjectId = ctx.publicProjectId; + let remoteFileBuckets = ctx.remoteFileBuckets; + let remoteFilesCounter = ctx.remoteFilesCounter; + + if (!publicProjectId || !remoteFileBuckets) { + if (!projectName) { + return { + success: false, + errorMessage: + "Project name not found. Add project name to val.config or set the VAL_PROJECT environment variable", + }; + } + const settingsRes = await ctx.remote.getSettings(projectName, { pat }); + if (!settingsRes.success) { + return { + success: false, + errorMessage: `Could not get public project id: ${settingsRes.message}.`, + }; + } + publicProjectId = settingsRes.data.publicProjectId; + remoteFileBuckets = settingsRes.data.remoteFileBuckets.map((b) => b.bucket); + } + + if (!publicProjectId) { + return { + success: false, + errorMessage: "Could not get public project id", + }; + } + + if (!projectName) { + return { + success: false, + errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`, + }; + } + + if ( + resolveRemoteFileSchema.type !== "image" && + resolveRemoteFileSchema.type !== "file" + ) { + return { + success: false, + errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`, + }; + } + + remoteFilesCounter += 1; + const bucket = + remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length]; + + if (!bucket) { + return { + success: false, + errorMessage: `Internal error: could not allocate a bucket for the remote file located at ${ctx.sourcePath}`, + }; + } + + const fileBuffer = ctx.fs.readBuffer(filePath); + if (fileBuffer === undefined) { + return { + success: false, + errorMessage: `Error reading file: ${filePath}`, + }; + } + + const relativeFilePath = path + .relative(ctx.projectRoot, filePath) + .split(path.sep) + .join("/") as `public/val/${string}`; + + if (!relativeFilePath.startsWith("public/val/")) { + return { + success: false, + errorMessage: `File path must be within the public/val/ directory (e.g. public/val/path/to/file.txt). Got: ${relativeFilePath}`, + }; + } + + const fileHash = Internal.remote.getFileHash(fileBuffer); + const coreVersion = Internal.VERSION.core || "unknown"; + const fileExt = getFileExt(filePath); + const schema = resolveRemoteFileSchema as + | SerializedImageSchema + | SerializedFileSchema; + const metadata = fileSourceMetadata; + const ref = Internal.remote.createRemoteRef(ctx.remote.remoteHost, { + publicProjectId, + coreVersion, + bucket, + validationHash: Internal.remote.getValidationHash( + coreVersion, + schema, + fileExt, + metadata, + fileHash, + textEncoder, + ), + fileHash, + filePath: relativeFilePath, + }); + + const remoteFileUpload = await ctx.remote.uploadFile( + projectName, + bucket, + fileHash, + fileExt, + fileBuffer, + { pat }, + ); + + if (!remoteFileUpload.success) { + return { + success: false, + errorMessage: `Could not upload remote file: '${ref}'. Error: ${remoteFileUpload.error}`, + }; + } + + ctx.remoteFiles[ctx.sourcePath] = { + ref, + metadata: fileSourceMetadata, + }; + + return { + success: true, + shouldApplyPatch: true, + publicProjectId, + remoteFileBuckets, + remoteFilesCounter, + events: [ + { type: "remote-uploading", ref }, + { type: "remote-uploaded", ref }, + ], + }; +} + +export async function handleRemoteFileDownload( + ctx: FixHandlerContext, +): Promise { + if (ctx.fix) { + return { + success: true, + shouldApplyPatch: true, + events: [{ type: "remote-downloading", sourcePath: ctx.sourcePath }], + }; + } else { + return { + success: false, + errorMessage: `Remote file ${ctx.sourcePath} needs to be downloaded (use --fix to download)`, + }; + } +} + +export async function handleRemoteFileCheck(): Promise { + // Skip - no action needed + return { success: true, shouldApplyPatch: true }; +} + +// Helper function +export async function checkKeyIsValid( + key: string, + sourcePath: string, + service: Service, + cache: KeyOfCache, +): Promise<{ error: false } | { error: true; message: string }> { + const [moduleFilePath, modulePath] = + Internal.splitModuleFilePathAndModulePath(sourcePath as SourcePath); + + const cacheKey = `${moduleFilePath}::${modulePath}`; + let keyOfModuleSource: unknown; + let keyOfModuleSchema: { type: string } | undefined; + + const cached = cache.get(cacheKey); + if (cached) { + keyOfModuleSource = cached.source; + keyOfModuleSchema = cached.schema; + } else { + const keyOfModule = await service.get(moduleFilePath, modulePath, { + source: true, + schema: true, + validate: false, + }); + keyOfModuleSource = keyOfModule.source; + keyOfModuleSchema = keyOfModule.schema as { type: string } | undefined; + cache.set(cacheKey, { + source: keyOfModuleSource, + schema: keyOfModuleSchema, + }); + } + + if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") { + return { + error: true, + message: `Expected key at ${sourcePath} to be of type 'record'`, + }; + } + if ( + keyOfModuleSource && + typeof keyOfModuleSource === "object" && + key in keyOfModuleSource + ) { + return { error: false }; + } + if (!keyOfModuleSource || typeof keyOfModuleSource !== "object") { + return { + error: true, + message: `Expected ${sourcePath} to be a truthy object`, + }; + } + const alternatives = findSimilar(key, Object.keys(keyOfModuleSource)); + return { + error: true, + message: `Key '${key}' does not exist in ${sourcePath}. Closest match: '${alternatives[0].target}'. Other similar: ${alternatives + .slice(1, 4) + .map((a) => `'${a.target}'`) + .join(", ")}${alternatives.length > 4 ? ", ..." : ""}`, + }; +} + +/** + * Check if a route is valid by scanning all router modules + * and validating against include/exclude patterns + */ +export async function checkRouteIsValid( + route: string, + include: SerializedRegExpPattern | undefined, + exclude: SerializedRegExpPattern | undefined, + service: Service, + valFiles: string[], + cache: RouterModulesCache, +): Promise<{ error: false } | { error: true; message: string }> { + // 1. Scan all val files to find modules with routers (use cache if available) + if (!cache.loaded) { + for (const file of valFiles) { + const moduleFilePath = `/${file}` as ModuleFilePath; + const valModule = await service.get(moduleFilePath, "" as ModulePath, { + source: true, + schema: true, + validate: false, + }); + + // Check if this module has a router defined + if (valModule.schema?.type === "record" && valModule.schema.router) { + if (valModule.source && typeof valModule.source === "object") { + cache.modules[moduleFilePath] = valModule.source as Record< + string, + unknown + >; + } + } + } + cache.loaded = true; + } + + const routerModules = cache.modules; + + // 2. Check if route exists in any router module + let foundInModule: string | null = null; + for (const [moduleFilePath, source] of Object.entries(routerModules)) { + if (route in source) { + foundInModule = moduleFilePath; + break; + } + } + + if (!foundInModule) { + // Route not found in any router module + let allRoutes = Object.values(routerModules).flatMap((source) => + Object.keys(source), + ); + + if (allRoutes.length === 0) { + return { + error: true, + message: `Route '${route}' could not be validated: No router modules found in the project. Use s.record(...).router(...) to define router modules.`, + }; + } + + // Filter routes by include/exclude patterns for suggestions + allRoutes = filterRoutesByPatterns(allRoutes, include, exclude); + + const alternatives = findSimilar(route, allRoutes); + + return { + error: true, + message: `Route '${route}' does not exist in any router module. ${ + alternatives.length > 0 + ? `Closest match: '${alternatives[0].target}'. Other similar: ${alternatives + .slice(1, 4) + .map((a) => `'${a.target}'`) + .join(", ")}${alternatives.length > 4 ? ", ..." : ""}` + : "No similar routes found." + }`, + }; + } + + // 3. Validate against include/exclude patterns + const patternValidation = validateRoutePatterns(route, include, exclude); + if (!patternValidation.valid) { + return { + error: true, + message: patternValidation.message, + }; + } + + return { error: false }; +} + +/** + * Handler for router:check-route validation fix + */ +export async function handleRouteCheck( + ctx: FixHandlerContext, +): Promise { + const { sourcePath, validationError, service, valFiles, routerModulesCache } = + ctx; + + // Extract route and patterns from validation error value + const value = validationError.value as + | { + route: unknown; + include?: { source: string; flags: string }; + exclude?: { source: string; flags: string }; + } + | undefined; + + if (!value || typeof value.route !== "string") { + return { + success: false, + errorMessage: `Invalid route value in validation error: ${JSON.stringify(value)}`, + }; + } + + const route = value.route; + + // Check if the route is valid + const result = await checkRouteIsValid( + route, + value.include, + value.exclude, + service, + valFiles, + routerModulesCache, + ); + + if (result.error) { + return { + success: false, + errorMessage: `${sourcePath}: ${result.message}`, + }; + } + + return { success: true }; +} + +// Fix handler registry +export const currentFixHandlers: Record = { + "image:check-metadata": handleFileMetadata, + "image:add-metadata": handleFileMetadata, + "file:check-metadata": handleFileMetadata, + "file:add-metadata": handleFileMetadata, + "keyof:check-keys": handleKeyOfCheck, + "router:check-route": handleRouteCheck, + "image:upload-remote": handleRemoteFileUpload, + "file:upload-remote": handleRemoteFileUpload, + "image:download-remote": handleRemoteFileDownload, + "file:download-remote": handleRemoteFileDownload, + "image:check-remote": handleRemoteFileCheck, + "images:check-remote": handleRemoteFileCheck, + "file:check-remote": handleRemoteFileCheck, + "files:check-remote": handleRemoteFileCheck, +}; +const deprecatedFixHandlers: Record = { + "image:replace-metadata": handleFileMetadata, +}; +export const fixHandlers: Record = { + ...deprecatedFixHandlers, + ...currentFixHandlers, +}; + +export function createDefaultValFSHost(): IValFSHost { + return { + ...ts.sys, + writeFile: (fileName, data, encoding) => { + nodeFs.mkdirSync(path.dirname(fileName), { recursive: true }); + nodeFs.writeFileSync( + fileName, + typeof data === "string" ? data : new Uint8Array(data), + encoding, + ); + }, + rmFile: nodeFs.rmSync, + readBuffer: (fileName) => { + try { + return nodeFs.readFileSync(fileName); + } catch { + return undefined; + } + }, + }; +} + +export async function* runValidation({ + root, + fix, + valFiles, + project, + remote, + fs, +}: { + root: string; + fix: boolean; + valFiles: string[]; + project: string | undefined; + remote: IValRemote; + fs: IValFSHost; +}): AsyncGenerator { + const projectRoot = path.resolve(root); + + const service = await createService(projectRoot, {}, fs); + + let errors = 0; + + // Create caches that persist across all file validations + const keyOfCache: KeyOfCache = new Map(); + const routerModulesCache: RouterModulesCache = { + loaded: false, + modules: {}, + }; + + async function* validateFile(file: string): AsyncGenerator { + const moduleFilePath = `/${file}` as ModuleFilePath; // TODO: check if this always works? (Windows?) + const start = Date.now(); + const valModule = await service.get(moduleFilePath, "" as ModulePath, { + source: true, + schema: true, + validate: true, + }); + const remoteFiles: Record< + SourcePath, + { ref: string; metadata?: Record } + > = {}; + let remoteFileBuckets: string[] | undefined = undefined; + let remoteFilesCounter = 0; + if (!valModule.errors) { + yield { + type: "file-valid", + file: moduleFilePath, + durationMs: Date.now() - start, + }; + return; + } else { + let fileErrors = 0; + let fixedErrors = 0; + if (valModule.errors) { + if (valModule.errors.validation) { + for (const [sourcePath, validationErrors] of Object.entries( + valModule.errors.validation, + )) { + for (const v of validationErrors) { + if (!v.fixes || v.fixes.length === 0) { + // No fixes available - just report error + fileErrors += 1; + yield { + type: "validation-error", + sourcePath, + message: v.message, + }; + continue; + } + + // Find and execute appropriate handler + const fixType = v.fixes[0]; // Take first fix + const handler = fixHandlers[fixType]; + + if (!handler) { + yield { + type: "unknown-fix", + sourcePath, + fixes: v.fixes, + }; + fileErrors += 1; + continue; + } + + // Execute handler + const result = await handler({ + sourcePath: sourcePath as SourcePath, + validationError: v, + valModule, + projectRoot, + fix: !!fix, + service, + valFiles, + moduleFilePath, + file, + fs, + remoteFiles, + publicProjectId: undefined, + remoteFileBuckets, + remoteFilesCounter, + remote, + project, + keyOfCache, + routerModulesCache, + }); + + // Yield any events from handler + if (result.events) { + for (const event of result.events) { + yield event; + } + } + + // Update shared state from handler result + if (result.remoteFileBuckets !== undefined) { + remoteFileBuckets = result.remoteFileBuckets; + } + if (result.remoteFilesCounter !== undefined) { + remoteFilesCounter = result.remoteFilesCounter; + } + + if (!result.success) { + yield { + type: "validation-error", + sourcePath, + message: result.errorMessage ?? "Unknown error", + }; + fileErrors += 1; + continue; + } + + // Apply patch if needed + if (result.shouldApplyPatch) { + const fixPatch = await createFixPatch( + { projectRoot, remoteHost: remote.remoteHost }, + !!fix, + sourcePath as SourcePath, + v, + remoteFiles, + valModule.source, + valModule.schema, + ); + + if (fix && fixPatch?.patch && fixPatch?.patch.length > 0) { + await service.patch(moduleFilePath, fixPatch.patch); + fixedErrors += 1; + yield { type: "fix-applied", file, sourcePath }; + } + + for (const e of fixPatch?.remainingErrors ?? []) { + fileErrors += 1; + yield { + type: "validation-fixable-error", + sourcePath, + message: e.message, + fixable: !!(e.fixes && e.fixes.length), + }; + } + } + } + } + } + if ( + fixedErrors === fileErrors && + (!valModule.errors.fatal || valModule.errors.fatal.length == 0) + ) { + yield { + type: "file-valid", + file: moduleFilePath, + durationMs: Date.now() - start, + }; + } + for (const fatalError of valModule.errors.fatal || []) { + fileErrors += 1; + yield { + type: "fatal-error", + file: moduleFilePath, + message: fatalError.message, + }; + } + } else { + yield { + type: "file-valid", + file: moduleFilePath, + durationMs: Date.now() - start, + }; + } + if (fileErrors > 0) { + yield { + type: "file-error-count", + file: `/${file}`, + errorCount: fileErrors, + durationMs: Date.now() - start, + }; + } + errors += fileErrors; + } + } + + for (const file of valFiles.sort()) { + yield* validateFile(file); + } + + service.dispose(); + + if (errors > 0) { + yield { type: "summary-errors", count: errors }; + } else { + yield { type: "summary-success" }; + } +} + +// GPT generated levenshtein distance algorithm: +export const levenshtein = (a: string, b: string): number => { + const [m, n] = [a.length, b.length]; + if (!m || !n) return Math.max(m, n); + + const dp = Array.from({ length: m + 1 }, (_, i) => i); + + for (let j = 1; j <= n; j++) { + let prev = dp[0]; + dp[0] = j; + + for (let i = 1; i <= m; i++) { + const temp = dp[i]; + dp[i] = + a[i - 1] === b[j - 1] + ? prev + : Math.min(prev + 1, dp[i - 1] + 1, dp[i] + 1); + prev = temp; + } + } + + return dp[m]; +}; + +export function findSimilar(key: string, targets: string[]) { + return targets + .map((target) => ({ target, distance: levenshtein(key, target) })) + .sort((a, b) => a.distance - b.distance); +} diff --git a/packages/cli/src/validate.ts b/packages/cli/src/validate.ts index 101c05a82..fa40d1f93 100644 --- a/packages/cli/src/validate.ts +++ b/packages/cli/src/validate.ts @@ -1,675 +1,10 @@ import path from "path"; -import { - createFixPatch, - createService, - getSettings, - getPersonalAccessTokenPath, - parsePersonalAccessTokenFile, - uploadRemoteFile, - Service, -} from "@valbuild/server"; -import { - DEFAULT_CONTENT_HOST, - DEFAULT_VAL_REMOTE_HOST, - FILE_REF_PROP, - Internal, - ModuleFilePath, - ModulePath, - SerializedFileSchema, - SerializedImageSchema, - SourcePath, - ValidationFix, -} from "@valbuild/core"; -import { - filterRoutesByPatterns, - validateRoutePatterns, - type SerializedRegExpPattern, -} from "@valbuild/shared/internal"; -import { glob } from "fast-glob"; import picocolors from "picocolors"; import fs from "fs/promises"; +import { glob } from "fast-glob"; +import { DEFAULT_CONTENT_HOST, DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core"; import { evalValConfigFile } from "./utils/evalValConfigFile"; -import { getFileExt } from "./utils/getFileExt"; - -const textEncoder = new TextEncoder(); - -// Types for handler system -type ValModule = Awaited>; - -type ValidationError = { - message: string; - value?: unknown; - fixes?: ValidationFix[]; -}; - -// Cache types for avoiding redundant service.get() calls -type KeyOfCache = Map< - string, // moduleFilePath + modulePath key - { source: unknown; schema: { type: string } | undefined } ->; -type RouterModulesCache = { - loaded: boolean; - modules: Record>; -}; - -type FixHandlerContext = { - sourcePath: SourcePath; - validationError: ValidationError; - valModule: ValModule; - projectRoot: string; - fix: boolean; - service: Service; - valFiles: string[]; - moduleFilePath: ModuleFilePath; - file: string; - // Shared state - remoteFiles: Record< - SourcePath, - { ref: string; metadata?: Record } - >; - publicProjectId?: string; - remoteFileBuckets?: string[]; - remoteFilesCounter: number; - valRemoteHost: string; - contentHostUrl: string; - valConfigFile?: { project?: string }; - // Caches for validation - keyOfCache: KeyOfCache; - routerModulesCache: RouterModulesCache; -}; - -type FixHandlerResult = { - success: boolean; - errorMessage?: string; - shouldApplyPatch?: boolean; - // Updated shared state - publicProjectId?: string; - remoteFileBuckets?: string[]; - remoteFilesCounter?: number; -}; - -type FixHandler = (ctx: FixHandlerContext) => Promise; - -// Handler functions -async function handleFileMetadata( - ctx: FixHandlerContext, -): Promise { - const [, modulePath] = Internal.splitModuleFilePathAndModulePath( - ctx.sourcePath, - ); - - if (!ctx.valModule.source || !ctx.valModule.schema) { - return { - success: false, - errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`, - }; - } - - const fileSource = Internal.resolvePath( - modulePath, - ctx.valModule.source, - ctx.valModule.schema, - ); - - let filePath: string | null = null; - try { - filePath = path.join( - ctx.projectRoot, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - (fileSource.source as any)?.[FILE_REF_PROP], - ); - await fs.access(filePath); - } catch { - if (filePath) { - return { - success: false, - errorMessage: `File ${filePath} does not exist`, - }; - } else { - return { - success: false, - errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`, - }; - } - } - - return { success: true, shouldApplyPatch: true }; -} - -async function handleKeyOfCheck( - ctx: FixHandlerContext, -): Promise { - if ( - !ctx.validationError.value || - typeof ctx.validationError.value !== "object" || - !("key" in ctx.validationError.value) || - !("sourcePath" in ctx.validationError.value) - ) { - return { - success: false, - errorMessage: `Unexpected error in ${ctx.sourcePath}: ${ctx.validationError.message} (Expected value to be an object with 'key' and 'sourcePath' properties - this is likely a bug in Val)`, - }; - } - - const { key, sourcePath } = ctx.validationError.value as { - key: unknown; - sourcePath: unknown; - }; - - if (typeof key !== "string") { - return { - success: false, - errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'key' to be a string - this is likely a bug in Val)`, - }; - } - - if (typeof sourcePath !== "string") { - return { - success: false, - errorMessage: `Unexpected error in ${sourcePath}: ${ctx.validationError.message} (Expected value property 'sourcePath' to be a string - this is likely a bug in Val)`, - }; - } - - const res = await checkKeyIsValid( - key, - sourcePath, - ctx.service, - ctx.keyOfCache, - ); - if (res.error) { - return { - success: false, - errorMessage: res.message, - }; - } - - return { success: true }; -} - -async function handleRemoteFileUpload( - ctx: FixHandlerContext, -): Promise { - if (!ctx.fix) { - return { - success: false, - errorMessage: `Remote file ${ctx.sourcePath} needs to be uploaded (use --fix to upload)`, - }; - } - - const [, modulePath] = Internal.splitModuleFilePathAndModulePath( - ctx.sourcePath, - ); - - if (!ctx.valModule.source || !ctx.valModule.schema) { - return { - success: false, - errorMessage: `Could not resolve source or schema for ${ctx.sourcePath}`, - }; - } - - const resolvedRemoteFileAtSourcePath = Internal.resolvePath( - modulePath, - ctx.valModule.source, - ctx.valModule.schema, - ); - - let filePath: string | null = null; - try { - filePath = path.join( - ctx.projectRoot, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - (resolvedRemoteFileAtSourcePath.source as any)?.[FILE_REF_PROP], - ); - await fs.access(filePath); - } catch { - if (filePath) { - return { - success: false, - errorMessage: `File ${filePath} does not exist`, - }; - } else { - return { - success: false, - errorMessage: `Expected file to be defined at: ${ctx.sourcePath} but no file was found`, - }; - } - } - - const patFile = getPersonalAccessTokenPath(ctx.projectRoot); - try { - await fs.access(patFile); - } catch { - return { - success: false, - errorMessage: `File: ${path.join(ctx.projectRoot, ctx.file)} has remote images that are not uploaded and you are not logged in.\n\nFix this error by logging in:\n\t"npx val login"\n`, - }; - } - - const parsedPatFile = parsePersonalAccessTokenFile( - await fs.readFile(patFile, "utf-8"), - ); - if (!parsedPatFile.success) { - return { - success: false, - errorMessage: `Error parsing personal access token file: ${parsedPatFile.error}. You need to login again.`, - }; - } - const { pat } = parsedPatFile.data; - - if (ctx.remoteFiles[ctx.sourcePath]) { - console.log( - picocolors.yellow("⚠"), - `Remote file ${filePath} already uploaded`, - ); - return { success: true }; - } - - if (!resolvedRemoteFileAtSourcePath.schema) { - return { - success: false, - errorMessage: `Cannot upload remote file: schema not found for ${ctx.sourcePath}`, - }; - } - - const actualRemoteFileSource = resolvedRemoteFileAtSourcePath.source; - const fileSourceMetadata = Internal.isFile(actualRemoteFileSource) - ? actualRemoteFileSource.metadata - : undefined; - const resolveRemoteFileSchema = resolvedRemoteFileAtSourcePath.schema; - - if (!resolveRemoteFileSchema) { - return { - success: false, - errorMessage: `Could not resolve schema for remote file: ${ctx.sourcePath}`, - }; - } - - let publicProjectId = ctx.publicProjectId; - let remoteFileBuckets = ctx.remoteFileBuckets; - let remoteFilesCounter = ctx.remoteFilesCounter; - - if (!publicProjectId || !remoteFileBuckets) { - let projectName = process.env.VAL_PROJECT; - if (!projectName) { - projectName = ctx.valConfigFile?.project; - } - if (!projectName) { - return { - success: false, - errorMessage: - "Project name not found. Set VAL_PROJECT environment variable or add project name to val.config", - }; - } - const settingsRes = await getSettings(projectName, { pat }); - if (!settingsRes.success) { - return { - success: false, - errorMessage: `Could not get public project id: ${settingsRes.message}.`, - }; - } - publicProjectId = settingsRes.data.publicProjectId; - remoteFileBuckets = settingsRes.data.remoteFileBuckets.map((b) => b.bucket); - } - - if (!publicProjectId) { - return { - success: false, - errorMessage: "Could not get public project id", - }; - } - - if (!ctx.valConfigFile?.project) { - return { - success: false, - errorMessage: `Could not get project. Check that your val.config has the 'project' field set, or set it using the VAL_PROJECT environment variable`, - }; - } - - if ( - resolveRemoteFileSchema.type !== "image" && - resolveRemoteFileSchema.type !== "file" - ) { - return { - success: false, - errorMessage: `The schema is the remote is neither image nor file: ${ctx.sourcePath}`, - }; - } - - remoteFilesCounter += 1; - const bucket = - remoteFileBuckets[remoteFilesCounter % remoteFileBuckets.length]; - - if (!bucket) { - return { - success: false, - errorMessage: `Internal error: could not allocate a bucket for the remote file located at ${ctx.sourcePath}`, - }; - } - - let fileBuffer: Buffer; - try { - fileBuffer = await fs.readFile(filePath); - } catch (e) { - return { - success: false, - errorMessage: `Error reading file: ${e}`, - }; - } - - const relativeFilePath = path - .relative(ctx.projectRoot, filePath) - .split(path.sep) - .join("/") as `public/val/${string}`; - - if (!relativeFilePath.startsWith("public/val/")) { - return { - success: false, - errorMessage: `File path must be within the public/val/ directory (e.g. public/val/path/to/file.txt). Got: ${relativeFilePath}`, - }; - } - - const fileHash = Internal.remote.getFileHash(fileBuffer); - const coreVersion = Internal.VERSION.core || "unknown"; - const fileExt = getFileExt(filePath); - const schema = resolveRemoteFileSchema as - | SerializedImageSchema - | SerializedFileSchema; - const metadata = fileSourceMetadata; - const ref = Internal.remote.createRemoteRef(ctx.valRemoteHost, { - publicProjectId, - coreVersion, - bucket, - validationHash: Internal.remote.getValidationHash( - coreVersion, - schema, - fileExt, - metadata, - fileHash, - textEncoder, - ), - fileHash, - filePath: relativeFilePath, - }); - - console.log(picocolors.yellow("⚠"), `Uploading remote file: '${ref}'...`); - - const remoteFileUpload = await uploadRemoteFile( - ctx.contentHostUrl, - ctx.valConfigFile.project, - bucket, - fileHash, - fileExt, - fileBuffer, - { pat }, - ); - - if (!remoteFileUpload.success) { - return { - success: false, - errorMessage: `Could not upload remote file: '${ref}'. Error: ${remoteFileUpload.error}`, - }; - } - - console.log( - picocolors.green("✔"), - `Completed upload of remote file: '${ref}'`, - ); - - ctx.remoteFiles[ctx.sourcePath] = { - ref, - metadata: fileSourceMetadata, - }; - - return { - success: true, - shouldApplyPatch: true, - publicProjectId, - remoteFileBuckets, - remoteFilesCounter, - }; -} - -async function handleRemoteFileDownload( - ctx: FixHandlerContext, -): Promise { - if (ctx.fix) { - console.log( - picocolors.yellow("⚠"), - `Downloading remote file in ${ctx.sourcePath}...`, - ); - return { success: true, shouldApplyPatch: true }; - } else { - return { - success: false, - errorMessage: `Remote file ${ctx.sourcePath} needs to be downloaded (use --fix to download)`, - }; - } -} - -async function handleRemoteFileCheck(): Promise { - // Skip - no action needed - return { success: true, shouldApplyPatch: true }; -} - -// Helper function -async function checkKeyIsValid( - key: string, - sourcePath: string, - service: Service, - cache: KeyOfCache, -): Promise<{ error: false } | { error: true; message: string }> { - const [moduleFilePath, modulePath] = - Internal.splitModuleFilePathAndModulePath(sourcePath as SourcePath); - - const cacheKey = `${moduleFilePath}::${modulePath}`; - let keyOfModuleSource: unknown; - let keyOfModuleSchema: { type: string } | undefined; - - const cached = cache.get(cacheKey); - if (cached) { - keyOfModuleSource = cached.source; - keyOfModuleSchema = cached.schema; - } else { - const keyOfModule = await service.get(moduleFilePath, modulePath, { - source: true, - schema: true, - validate: false, - }); - keyOfModuleSource = keyOfModule.source; - keyOfModuleSchema = keyOfModule.schema as { type: string } | undefined; - cache.set(cacheKey, { - source: keyOfModuleSource, - schema: keyOfModuleSchema, - }); - } - - if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") { - return { - error: true, - message: `Expected key at ${sourcePath} to be of type 'record'`, - }; - } - if ( - keyOfModuleSource && - typeof keyOfModuleSource === "object" && - key in keyOfModuleSource - ) { - return { error: false }; - } - if (!keyOfModuleSource || typeof keyOfModuleSource !== "object") { - return { - error: true, - message: `Expected ${sourcePath} to be a truthy object`, - }; - } - const alternatives = findSimilar(key, Object.keys(keyOfModuleSource)); - return { - error: true, - message: `Key '${key}' does not exist in ${sourcePath}. Closest match: '${alternatives[0].target}'. Other similar: ${alternatives - .slice(1, 4) - .map((a) => `'${a.target}'`) - .join(", ")}${alternatives.length > 4 ? ", ..." : ""}`, - }; -} - -/** - * Check if a route is valid by scanning all router modules - * and validating against include/exclude patterns - */ -async function checkRouteIsValid( - route: string, - include: SerializedRegExpPattern | undefined, - exclude: SerializedRegExpPattern | undefined, - service: Service, - valFiles: string[], - cache: RouterModulesCache, -): Promise<{ error: false } | { error: true; message: string }> { - // 1. Scan all val files to find modules with routers (use cache if available) - if (!cache.loaded) { - for (const file of valFiles) { - const moduleFilePath = `/${file}` as ModuleFilePath; - const valModule = await service.get(moduleFilePath, "" as ModulePath, { - source: true, - schema: true, - validate: false, - }); - - // Check if this module has a router defined - if (valModule.schema?.type === "record" && valModule.schema.router) { - if (valModule.source && typeof valModule.source === "object") { - cache.modules[moduleFilePath] = valModule.source as Record< - string, - unknown - >; - } - } - } - cache.loaded = true; - } - - const routerModules = cache.modules; - - // 2. Check if route exists in any router module - let foundInModule: string | null = null; - for (const [moduleFilePath, source] of Object.entries(routerModules)) { - if (route in source) { - foundInModule = moduleFilePath; - break; - } - } - - if (!foundInModule) { - // Route not found in any router module - let allRoutes = Object.values(routerModules).flatMap((source) => - Object.keys(source), - ); - - if (allRoutes.length === 0) { - return { - error: true, - message: `Route '${route}' could not be validated: No router modules found in the project. Use s.record(...).router(...) to define router modules.`, - }; - } - - // Filter routes by include/exclude patterns for suggestions - allRoutes = filterRoutesByPatterns(allRoutes, include, exclude); - - const alternatives = findSimilar(route, allRoutes); - - return { - error: true, - message: `Route '${route}' does not exist in any router module. ${ - alternatives.length > 0 - ? `Closest match: '${alternatives[0].target}'. Other similar: ${alternatives - .slice(1, 4) - .map((a) => `'${a.target}'`) - .join(", ")}${alternatives.length > 4 ? ", ..." : ""}` - : "No similar routes found." - }`, - }; - } - - // 3. Validate against include/exclude patterns - const patternValidation = validateRoutePatterns(route, include, exclude); - if (!patternValidation.valid) { - return { - error: true, - message: patternValidation.message, - }; - } - - return { error: false }; -} - -/** - * Handler for router:check-route validation fix - */ -async function handleRouteCheck( - ctx: FixHandlerContext, -): Promise { - const { sourcePath, validationError, service, valFiles, routerModulesCache } = - ctx; - - // Extract route and patterns from validation error value - const value = validationError.value as - | { - route: unknown; - include?: { source: string; flags: string }; - exclude?: { source: string; flags: string }; - } - | undefined; - - if (!value || typeof value.route !== "string") { - return { - success: false, - errorMessage: `Invalid route value in validation error: ${JSON.stringify(value)}`, - }; - } - - const route = value.route; - - // Check if the route is valid - const result = await checkRouteIsValid( - route, - value.include, - value.exclude, - service, - valFiles, - routerModulesCache, - ); - - if (result.error) { - return { - success: false, - errorMessage: `${sourcePath}: ${result.message}`, - }; - } - - return { success: true }; -} - -// Fix handler registry -const currentFixHandlers: Record = { - "image:check-metadata": handleFileMetadata, - "image:add-metadata": handleFileMetadata, - "file:check-metadata": handleFileMetadata, - "file:add-metadata": handleFileMetadata, - "keyof:check-keys": handleKeyOfCheck, - "router:check-route": handleRouteCheck, - "image:upload-remote": handleRemoteFileUpload, - "file:upload-remote": handleRemoteFileUpload, - "image:download-remote": handleRemoteFileDownload, - "file:download-remote": handleRemoteFileDownload, - "image:check-remote": handleRemoteFileCheck, - "file:check-remote": handleRemoteFileCheck, -}; -const deprecatedFixHandlers: Record = { - "image:replace-metadata": handleFileMetadata, -}; -const fixHandlers: Record = { - ...deprecatedFixHandlers, - ...currentFixHandlers, -}; +import { createDefaultValFSHost, runValidation } from "./runValidation"; export async function validate({ root, @@ -678,265 +13,163 @@ export async function validate({ root?: string; fix?: boolean; }) { - const valRemoteHost = process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST; - const contentHostUrl = process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST; const projectRoot = root ? path.resolve(root) : process.cwd(); + const valConfigFile = (await evalValConfigFile(projectRoot, "val.config.ts")) || (await evalValConfigFile(projectRoot, "val.config.js")); + + const resolvedValConfigFile = valConfigFile + ? { + ...valConfigFile, + project: process.env.VAL_PROJECT || valConfigFile.project, + } + : process.env.VAL_PROJECT + ? { project: process.env.VAL_PROJECT } + : undefined; + console.log( picocolors.greenBright( - `Validating project${valConfigFile?.project ? ` '${picocolors.inverse(valConfigFile?.project)}'` : ""}...`, + `Validating project${resolvedValConfigFile?.project ? ` '${picocolors.inverse(resolvedValConfigFile.project)}'` : ""}...`, ), ); - const service = await createService(projectRoot, {}); - let prettier; - try { - prettier = (await import("prettier")).default; - } catch { - console.log("Prettier not found, skipping formatting"); - } const valFiles: string[] = await glob("**/*.val.{js,ts}", { ignore: ["node_modules/**"], cwd: projectRoot, }); - let errors = 0; console.log(picocolors.greenBright(`Found ${valFiles.length} files...`)); - let publicProjectId: string | undefined; - let didFix = false; - - // Create caches that persist across all file validations - const keyOfCache: KeyOfCache = new Map(); - const routerModulesCache: RouterModulesCache = { loaded: false, modules: {} }; - - async function validateFile(file: string): Promise { - const moduleFilePath = `/${file}` as ModuleFilePath; // TODO: check if this always works? (Windows?) - const start = Date.now(); - const valModule = await service.get(moduleFilePath, "" as ModulePath, { - source: true, - schema: true, - validate: true, - }); - const remoteFiles: Record< - SourcePath, - { ref: string; metadata?: Record } - > = {}; - let remoteFileBuckets: string[] | undefined = undefined; - let remoteFilesCounter = 0; - if (!valModule.errors) { - console.log( - picocolors.green("✔"), - moduleFilePath, - "is valid (" + (Date.now() - start) + "ms)", - ); - return 0; - } else { - let errors = 0; - let fixedErrors = 0; - if (valModule.errors) { - if (valModule.errors.validation) { - for (const [sourcePath, validationErrors] of Object.entries( - valModule.errors.validation, - )) { - for (const v of validationErrors) { - if (!v.fixes || v.fixes.length === 0) { - // No fixes available - just report error - errors += 1; - console.log( - picocolors.red("✘"), - "Got error in", - `${sourcePath}:`, - v.message, - ); - continue; - } - - // Find and execute appropriate handler - const fixType = v.fixes[0]; // Take first fix - const handler = fixHandlers[fixType]; - if (!handler) { - console.log( - picocolors.red("✘"), - "Unknown fix", - v.fixes, - "for", - sourcePath, - ); - errors += 1; - continue; - } - - // Execute handler - const result = await handler({ - sourcePath: sourcePath as SourcePath, - validationError: v, - valModule, - projectRoot, - fix: !!fix, - service, - valFiles, - moduleFilePath, - file, - remoteFiles, - publicProjectId, - remoteFileBuckets, - remoteFilesCounter, - valRemoteHost, - contentHostUrl, - valConfigFile: valConfigFile ?? undefined, - keyOfCache, - routerModulesCache, - }); - - // Update shared state from handler result - if (result.publicProjectId !== undefined) { - publicProjectId = result.publicProjectId; - } - if (result.remoteFileBuckets !== undefined) { - remoteFileBuckets = result.remoteFileBuckets; - } - if (result.remoteFilesCounter !== undefined) { - remoteFilesCounter = result.remoteFilesCounter; - } - - if (!result.success) { - console.log(picocolors.red("✘"), result.errorMessage); - errors += 1; - continue; - } - - // Apply patch if needed - if (result.shouldApplyPatch) { - const fixPatch = await createFixPatch( - { projectRoot, remoteHost: valRemoteHost }, - !!fix, - sourcePath as SourcePath, - v, - remoteFiles, - valModule.source, - valModule.schema, - ); + let prettier; + try { + prettier = (await import("prettier")).default; + } catch { + console.log("Prettier not found, skipping formatting"); + } - if (fix && fixPatch?.patch && fixPatch?.patch.length > 0) { - await service.patch(moduleFilePath, fixPatch.patch); - didFix = true; - fixedErrors += 1; - console.log( - picocolors.yellow("⚠"), - "Applied fix for", - sourcePath, - ); - } + const fixedFiles = new Set(); + let totalErrors = 0; - fixPatch?.remainingErrors?.forEach((e) => { - errors += 1; - console.log( - e.fixes && e.fixes.length - ? picocolors.yellow("⚠") - : picocolors.red("✘"), - `Got ${e.fixes && e.fixes.length ? "fixable " : ""}error in`, - `${sourcePath}:`, - e.message, - ); - }); - } - } - } - } - if ( - fixedErrors === errors && - (!valModule.errors.fatal || valModule.errors.fatal.length == 0) - ) { - console.log( - picocolors.green("✔"), - moduleFilePath, - "is valid (" + (Date.now() - start) + "ms)", - ); - } - for (const fatalError of valModule.errors.fatal || []) { - errors += 1; - console.log( - picocolors.red("✘"), - moduleFilePath, - "is invalid:", - fatalError.message, - ); - } - } else { + for await (const event of runValidation({ + root: projectRoot, + fix: !!fix, + valFiles, + valConfigFile: resolvedValConfigFile, + hosts: { + remoteHost: process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST, + contentUrl: process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST, + }, + fs: createDefaultValFSHost(), + })) { + switch (event.type) { + case "file-valid": console.log( picocolors.green("✔"), - moduleFilePath, - "is valid (" + (Date.now() - start) + "ms)", + event.file, + "is valid (" + event.durationMs + "ms)", ); - } - if (errors > 0) { + break; + case "file-error-count": console.log( picocolors.red("✘"), - `${`/${file}`} contains ${errors} error${errors > 1 ? "s" : ""}`, - " (" + (Date.now() - start) + "ms)", + `${event.file} contains ${event.errorCount} error${event.errorCount > 1 ? "s" : ""}`, + " (" + event.durationMs + "ms)", ); - } - return errors; + totalErrors += event.errorCount; + break; + case "validation-error": + console.log( + picocolors.red("✘"), + "Got error in", + `${event.sourcePath}:`, + event.message, + ); + break; + case "validation-fixable-error": + console.log( + event.fixable ? picocolors.yellow("⚠") : picocolors.red("✘"), + `Got ${event.fixable ? "fixable " : ""}error in`, + `${event.sourcePath}:`, + event.message, + ); + break; + case "unknown-fix": + console.log( + picocolors.red("✘"), + "Unknown fix", + event.fixes, + "for", + event.sourcePath, + ); + break; + case "fix-applied": + console.log( + picocolors.yellow("⚠"), + "Applied fix for", + event.sourcePath, + ); + fixedFiles.add(event.file); + break; + case "fatal-error": + console.log( + picocolors.red("✘"), + event.file, + "is invalid:", + event.message, + ); + break; + case "remote-uploading": + console.log( + picocolors.yellow("⚠"), + `Uploading remote file: '${event.ref}'...`, + ); + break; + case "remote-uploaded": + console.log( + picocolors.green("✔"), + `Completed upload of remote file: '${event.ref}'`, + ); + break; + case "remote-already-uploaded": + console.log( + picocolors.yellow("⚠"), + `Remote file ${event.filePath} already uploaded`, + ); + break; + case "remote-downloading": + console.log( + picocolors.yellow("⚠"), + `Downloading remote file in ${event.sourcePath}...`, + ); + break; + case "summary-errors": + case "summary-success": + break; } } - for (const file of valFiles.sort()) { - didFix = false; - errors += await validateFile(file); - if (prettier && didFix) { + // Run prettier on files that had fixes applied + if (prettier) { + for (const file of fixedFiles) { const filePath = path.join(projectRoot, file); const fileContent = await fs.readFile(filePath, "utf-8"); - const formattedContent = await prettier?.format(fileContent, { + const formattedContent = await prettier.format(fileContent, { filepath: filePath, }); await fs.writeFile(filePath, formattedContent); } } - if (errors > 0) { + + if (totalErrors > 0) { console.log( picocolors.red("✘"), "Got", - errors, - "error" + (errors > 1 ? "s" : ""), + totalErrors, + "error" + (totalErrors > 1 ? "s" : ""), ); process.exit(1); } else { console.log(picocolors.green("✔"), "No validation errors found"); } - - service.dispose(); - return; -} - -// GPT generated levenshtein distance algorithm: -const levenshtein = (a: string, b: string): number => { - const [m, n] = [a.length, b.length]; - if (!m || !n) return Math.max(m, n); - - const dp = Array.from({ length: m + 1 }, (_, i) => i); - - for (let j = 1; j <= n; j++) { - let prev = dp[0]; - dp[0] = j; - - for (let i = 1; i <= m; i++) { - const temp = dp[i]; - dp[i] = - a[i - 1] === b[j - 1] - ? prev - : Math.min(prev + 1, dp[i - 1] + 1, dp[i] + 1); - prev = temp; - } - } - - return dp[m]; -}; - -function findSimilar(key: string, targets: string[]) { - return targets - .map((target) => ({ target, distance: levenshtein(key, target) })) - .sort((a, b) => a.distance - b.distance); } diff --git a/packages/server/src/Service.ts b/packages/server/src/Service.ts index 4edfa1347..9b2c677cd 100644 --- a/packages/server/src/Service.ts +++ b/packages/server/src/Service.ts @@ -42,6 +42,13 @@ export async function createService( ); }, rmFile: fs.rmSync, + readBuffer: (fileName) => { + try { + return fs.readFileSync(fileName); + } catch { + return undefined; + } + }, }, loader?: ValModuleLoader, ): Promise { diff --git a/packages/server/src/ValFS.ts b/packages/server/src/ValFS.ts index c739ae1dc..7a9c25dd9 100644 --- a/packages/server/src/ValFS.ts +++ b/packages/server/src/ValFS.ts @@ -22,6 +22,8 @@ export interface ValFS { readFile(filePath: string): string | undefined; + readBuffer(filePath: string): Buffer | undefined; + rmFile(filePath: string): void; realpath(path: string): string; diff --git a/packages/server/src/ValFSHost.ts b/packages/server/src/ValFSHost.ts index 4624f63f8..06628f24b 100644 --- a/packages/server/src/ValFSHost.ts +++ b/packages/server/src/ValFSHost.ts @@ -17,6 +17,7 @@ export interface IValFSHost encoding: "binary" | "utf8", ): void; rmFile(fileName: string): void; + readBuffer(fileName: string): Buffer | undefined; } export class ValFSHost implements IValFSHost { @@ -73,6 +74,10 @@ export class ValFSHost implements IValFSHost { return this.valFS.readFile(fileName); } + readBuffer(fileName: string): Buffer | undefined { + return this.valFS.readBuffer(fileName); + } + realpath(path: string): string { return this.valFS.realpath(path); } diff --git a/packages/server/src/ValModuleLoader.ts b/packages/server/src/ValModuleLoader.ts index 16a44d078..7d7ff6f04 100644 --- a/packages/server/src/ValModuleLoader.ts +++ b/packages/server/src/ValModuleLoader.ts @@ -27,6 +27,13 @@ export const createModuleLoader = ( ); }, rmFile: fs.rmSync, + readBuffer: (fileName) => { + try { + return fs.readFileSync(fileName); + } catch { + return undefined; + } + }, }, ): ValModuleLoader => { const compilerOptions = getCompilerOptions(rootDir, host); @@ -66,6 +73,13 @@ export class ValModuleLoader { ); }, rmFile: fs.rmSync, + readBuffer: (fileName) => { + try { + return fs.readFileSync(fileName); + } catch { + return undefined; + } + }, }, private readonly disableCache: boolean = false, ) { diff --git a/packages/server/src/ValSourceFileHandler.ts b/packages/server/src/ValSourceFileHandler.ts index 9c096d69b..4dd68c0fe 100644 --- a/packages/server/src/ValSourceFileHandler.ts +++ b/packages/server/src/ValSourceFileHandler.ts @@ -18,6 +18,13 @@ export class ValSourceFileHandler { ); }, rmFile: fs.rmSync, + readBuffer: (fileName) => { + try { + return fs.readFileSync(fileName); + } catch { + return undefined; + } + }, }, ) {} From e6a6a51a6248e21201edea713255fe4d4b92a7df Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Sat, 7 Mar 2026 18:01:46 +0100 Subject: [PATCH 30/32] Implement remote val for cli validate --- packages/cli/src/validate.ts | 18 +++++++++++++++--- 1 file changed, 15 insertions(+), 3 deletions(-) diff --git a/packages/cli/src/validate.ts b/packages/cli/src/validate.ts index fa40d1f93..241c674fe 100644 --- a/packages/cli/src/validate.ts +++ b/packages/cli/src/validate.ts @@ -3,6 +3,7 @@ import picocolors from "picocolors"; import fs from "fs/promises"; import { glob } from "fast-glob"; import { DEFAULT_CONTENT_HOST, DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core"; +import { getSettings, uploadRemoteFile } from "@valbuild/server"; import { evalValConfigFile } from "./utils/evalValConfigFile"; import { createDefaultValFSHost, runValidation } from "./runValidation"; @@ -55,10 +56,21 @@ export async function validate({ root: projectRoot, fix: !!fix, valFiles, - valConfigFile: resolvedValConfigFile, - hosts: { + project: resolvedValConfigFile?.project, + remote: { remoteHost: process.env.VAL_REMOTE_HOST || DEFAULT_VAL_REMOTE_HOST, - contentUrl: process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST, + getSettings: (projectName, options) => + getSettings(projectName, options), + uploadFile: (project, bucket, fileHash, fileExt, fileBuffer, options) => + uploadRemoteFile( + process.env.VAL_CONTENT_URL || DEFAULT_CONTENT_HOST, + project, + bucket, + fileHash, + fileExt ?? "", + fileBuffer, + options, + ), }, fs: createDefaultValFSHost(), })) { From e8e7dc3b4e1b734e0fcc7dde15d8100a100ca682 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 9 Mar 2026 17:42:54 +0000 Subject: [PATCH 31/32] Add runValidation test with validation error --- .../basic/content/basic-errors.val.ts | 7 ++++ .../basic/content/basic-valid.val.ts | 7 ++++ .../__fixtures__/basic/content/test.val.ts | 5 --- .../cli/src/__fixtures__/basic/val.config.ts | 5 +++ packages/cli/src/runValidation.test.ts | 38 +++++++++++++++++-- 5 files changed, 54 insertions(+), 8 deletions(-) create mode 100644 packages/cli/src/__fixtures__/basic/content/basic-errors.val.ts create mode 100644 packages/cli/src/__fixtures__/basic/content/basic-valid.val.ts delete mode 100644 packages/cli/src/__fixtures__/basic/content/test.val.ts create mode 100644 packages/cli/src/__fixtures__/basic/val.config.ts diff --git a/packages/cli/src/__fixtures__/basic/content/basic-errors.val.ts b/packages/cli/src/__fixtures__/basic/content/basic-errors.val.ts new file mode 100644 index 000000000..11042ad19 --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/content/basic-errors.val.ts @@ -0,0 +1,7 @@ +import { c, s } from "../val.config"; + +export default c.define( + "/content/basic-errors.val.ts", + s.string().minLength(30), + "Hello World", +); diff --git a/packages/cli/src/__fixtures__/basic/content/basic-valid.val.ts b/packages/cli/src/__fixtures__/basic/content/basic-valid.val.ts new file mode 100644 index 000000000..d56661e9f --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/content/basic-valid.val.ts @@ -0,0 +1,7 @@ +import { c, s } from "../val.config"; + +export default c.define( + "/content/basic-valid.val.ts", + s.string(), + "Hello World", +); diff --git a/packages/cli/src/__fixtures__/basic/content/test.val.ts b/packages/cli/src/__fixtures__/basic/content/test.val.ts deleted file mode 100644 index 131f094b9..000000000 --- a/packages/cli/src/__fixtures__/basic/content/test.val.ts +++ /dev/null @@ -1,5 +0,0 @@ -import { initVal } from "@valbuild/core"; - -const { s, c } = initVal(); - -export default c.define("/content/test.val.ts", s.string(), "Hello World"); diff --git a/packages/cli/src/__fixtures__/basic/val.config.ts b/packages/cli/src/__fixtures__/basic/val.config.ts new file mode 100644 index 000000000..8db86c966 --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/val.config.ts @@ -0,0 +1,5 @@ +import { initVal } from "@valbuild/core"; + +const { s, c } = initVal(); + +export { s, c }; diff --git a/packages/cli/src/runValidation.test.ts b/packages/cli/src/runValidation.test.ts index 7775948e9..17809eb04 100644 --- a/packages/cli/src/runValidation.test.ts +++ b/packages/cli/src/runValidation.test.ts @@ -1,5 +1,6 @@ -import { describe, test, expect } from "@jest/globals"; +import { describe, test, expect, beforeEach, afterEach } from "@jest/globals"; import path from "path"; +import fs from "fs"; import { DEFAULT_VAL_REMOTE_HOST } from "@valbuild/core"; import { createDefaultValFSHost, @@ -21,13 +22,26 @@ const mockRemote: IValRemote = { }; describe("runValidation", () => { + let tmpDir: string; + + beforeEach(() => { + const tmpBase = path.join(__dirname, ".tmp"); + fs.mkdirSync(tmpBase, { recursive: true }); + tmpDir = fs.mkdtempSync(path.join(tmpBase, "runValidation-")); + fs.cpSync(BASIC_FIXTURE, tmpDir, { recursive: true }); + }); + + afterEach(() => { + fs.rmSync(tmpDir, { recursive: true, force: true }); + }); + test("returns summary-success for a valid module", async () => { const events: ValidationEvent[] = []; for await (const event of runValidation({ - root: BASIC_FIXTURE, + root: tmpDir, fix: false, - valFiles: ["content/test.val.ts"], + valFiles: ["content/basic-valid.val.ts"], project: undefined, remote: mockRemote, fs: createDefaultValFSHost(), @@ -38,4 +52,22 @@ describe("runValidation", () => { expect(events.at(-1)).toEqual({ type: "summary-success" }); expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0); }); + + test("returns validation-error for a module with minLength violation", async () => { + const events: ValidationEvent[] = []; + + for await (const event of runValidation({ + root: tmpDir, + fix: false, + valFiles: ["content/basic-errors.val.ts"], + project: undefined, + remote: mockRemote, + fs: createDefaultValFSHost(), + })) { + events.push(event); + } + + expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 }); + expect(events.filter((e) => e.type === "validation-error")).toHaveLength(1); + }); }); From 56bd0c0ebfc5cdec22b7fb235192353e457f7085 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Mon, 9 Mar 2026 17:43:09 +0000 Subject: [PATCH 32/32] Add runValidation test with image with fix --- .../basic/content/basic-image.val.ts | 7 ++ .../__fixtures__/basic/public/val/image.png | Bin 0 -> 67 bytes packages/cli/src/runValidation.test.ts | 69 +++++++++++++++++- packages/core/src/patch/util.ts | 1 + 4 files changed, 76 insertions(+), 1 deletion(-) create mode 100644 packages/cli/src/__fixtures__/basic/content/basic-image.val.ts create mode 100644 packages/cli/src/__fixtures__/basic/public/val/image.png diff --git a/packages/cli/src/__fixtures__/basic/content/basic-image.val.ts b/packages/cli/src/__fixtures__/basic/content/basic-image.val.ts new file mode 100644 index 000000000..6db197ab5 --- /dev/null +++ b/packages/cli/src/__fixtures__/basic/content/basic-image.val.ts @@ -0,0 +1,7 @@ +import { c, s } from "../val.config"; + +export default c.define( + "/content/basic-image.val.ts", + s.image(), + c.image("/public/val/image.png"), +); diff --git a/packages/cli/src/__fixtures__/basic/public/val/image.png b/packages/cli/src/__fixtures__/basic/public/val/image.png new file mode 100644 index 0000000000000000000000000000000000000000..252d9502d8573d033e633f5e377d81bebf8afd36 GIT binary patch literal 67 zcmeAS@N?(olHy`uVBq!ia0vp^j35jm7|ip2ssJf2PZ!6K3dZCFAe)JSvAC2`0?1 { expect(events.at(-1)).toEqual({ type: "summary-errors", count: 1 }); expect(events.filter((e) => e.type === "validation-error")).toHaveLength(1); }); + + test("applies metadata fix for image without metadata", async () => { + const events: ValidationEvent[] = []; + + for await (const event of runValidation({ + root: tmpDir, + fix: true, + valFiles: ["content/basic-image.val.ts"], + project: undefined, + remote: mockRemote, + fs: createDefaultValFSHost(), + })) { + events.push(event); + } + + expect(events.at(-1)).toEqual({ type: "summary-success" }); + expect(events.filter((e) => e.type === "validation-error")).toHaveLength(0); + expect(events.filter((e) => e.type === "fix-applied")).toHaveLength(1); + expect(events.find((e) => e.type === "fix-applied")).toMatchObject({ + type: "fix-applied", + sourcePath: "/content/basic-image.val.ts", + }); + }); + + test("image has metadata after applying fix", async () => { + const gen = runValidation({ + root: tmpDir, + fix: true, + valFiles: ["content/basic-image.val.ts"], + project: undefined, + remote: mockRemote, + fs: createDefaultValFSHost(), + }); + // consume all events to apply fixes + let next = await gen.next(); + while (!next.done) { + next = await gen.next(); + } + + const service = await createService(tmpDir, {}, createDefaultValFSHost()); + try { + const result = await service.get( + "/content/basic-image.val.ts" as ModuleFilePath, + "" as ModulePath, + { source: true, schema: true, validate: true }, + ); + // The schema always emits image:check-metadata when metadata exists + // (actual metadata verification happens in the fix handler). + // Verify no image:add-metadata errors remain (fix was applied): + if (result.errors && result.errors.validation) { + const allFixes = Object.values(result.errors.validation) + .flat() + .flatMap((e) => e.fixes ?? []); + expect(allFixes).not.toContain("image:add-metadata"); + } + expect(result.source).toMatchObject({ + metadata: { + width: 1, + height: 1, + mimeType: "image/png", + }, + }); + } finally { + service.dispose(); + } + }); }); diff --git a/packages/core/src/patch/util.ts b/packages/core/src/patch/util.ts index 397280a3c..56707ccd6 100644 --- a/packages/core/src/patch/util.ts +++ b/packages/core/src/patch/util.ts @@ -70,5 +70,6 @@ export function parseAndValidateArrayIndex( export function sourceToPatchPath(sourcePath: SourcePath) { const [, modulePath] = splitModuleFilePathAndModulePath(sourcePath); + if (!modulePath) return []; return modulePath.split(".").map((p) => JSON.parse(p).toString()); }
+ {missingModules.length > 0 && ( +
+ {missingModules.length === 1 + ? `The module '${missingModules[0]}' is referenced by this field but is not added to val.modules. Add it to val.modules to enable uploads.` + : `The following modules are referenced by this field but are not added to val.modules: ${missingModules.join(", ")}. Add them to val.modules to enable uploads.`} +
+ )} {error && (
{error} @@ -352,13 +367,13 @@ export function FileField({ path }: { path: SourcePath }) { }).url } /> -
) : ( <> - ( @@ -173,7 +175,13 @@ export function ImageField({ path }: { path: SourcePath }) { schemaAtPath.data.type === "image" && schemaAtPath.data.remote && remoteFiles.status !== "ready"; - const disabled = remoteFileUploadDisabled; + const missingModules = + schemaAtPath.data.moduleMetadata && schemas.status === "success" + ? Object.keys(schemaAtPath.data.moduleMetadata).filter( + (modulePath) => !schemas.data[modulePath as ModuleFilePath], + ) + : []; + const disabled = remoteFileUploadDisabled || missingModules.length > 0; const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -192,6 +200,13 @@ export function ImageField({ path }: { path: SourcePath }) { return (
+ {missingModules.length > 0 && ( +
+ {missingModules.length === 1 + ? `The module '${missingModules[0]}' is referenced by this field but is not added to val.modules. Add it to val.modules to enable uploads.` + : `The following modules are referenced by this field but are not added to val.modules: ${missingModules.join(", ")}. Add them to val.modules to enable uploads.`} +
+ )} {error && (
{error} @@ -384,11 +399,11 @@ export function ImageField({ path }: { path: SourcePath }) { portalContainer={portalContainer} /> )} - Date: Thu, 26 Feb 2026 18:01:29 +0000 Subject: [PATCH 17/32] Limit the amount of s.file s.image referenced modules --- packages/core/src/schema/file.ts | 6 ------ packages/core/src/schema/image.ts | 6 ------ 2 files changed, 12 deletions(-) diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index 94b5c3b37..be0980787 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -346,7 +346,6 @@ export class FileSchema< export const file = ( options?: FileOptions | ValModule>, - ...args: ValModule>[] ): FileSchema> => { const isModule = !!options && @@ -357,7 +356,6 @@ export const file = ( const allModules: Record> = {}; for (const valModule of [ options as ValModule>, - ...args, ]) { const modulePath = getValPath(valModule) as ModulePath | undefined; if (modulePath === undefined) { @@ -371,10 +369,6 @@ export const file = ( >; } return new FileSchema({}, false, false, [], allModules); - } else if (args.length > 0) { - throw new Error( - `When passing a options to s.file(), you cannot pass additional arguments.`, - ); } return new FileSchema(options as FileOptions); }; diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index f732df917..3373d903b 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -379,7 +379,6 @@ export class ImageSchema< export const image = ( options?: ImageOptions | ValModule>, - ...args: ValModule>[] ): ImageSchema> => { const isModule = !!options && @@ -390,7 +389,6 @@ export const image = ( const allModules: Record> = {}; for (const valModule of [ options as ValModule>, - ...args, ]) { const modulePath = getValPath(valModule) as ModulePath | undefined; if (modulePath === undefined) { @@ -404,10 +402,6 @@ export const image = ( >; } return new ImageSchema({}, false, false, [], allModules); - } else if (args.length > 0) { - throw new Error( - `When passing a options to s.image(), you cannot pass additional arguments.`, - ); } return new ImageSchema(options as ImageOptions); }; From 926eaa42af82113bf6f729aba74615b831b41c4e Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Thu, 26 Feb 2026 18:10:09 +0000 Subject: [PATCH 18/32] Use accept if s.file / s.image is referenced module --- .../ui/spa/components/fields/FileField.tsx | 37 +++++++++++++++++-- .../ui/spa/components/fields/ImageField.tsx | 37 +++++++++++++++++-- 2 files changed, 66 insertions(+), 8 deletions(-) diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index fbcdcc8c3..80c401157 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -33,7 +33,7 @@ import { PreviewLoading, PreviewNull } from "../Preview"; import { File, Loader2, SquareArrowOutUpRight } from "lucide-react"; import { readFile } from "../../utils/readFile"; import { Button } from "../designSystem/button"; -import { useState } from "react"; +import { useMemo, useState } from "react"; import { getFileExt } from "../../utils/getFileExt"; import { useEffect } from "react"; import { useValPortal } from "../ValPortalProvider"; @@ -128,8 +128,12 @@ export function FileField({ path }: { path: SourcePath }) { const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< string | null >(null); - const { addPatch, patchPath, addAndUploadPatchWithFileOps, addModuleFilePatch } = - useAddPatch(path); + const { + addPatch, + patchPath, + addAndUploadPatchWithFileOps, + addModuleFilePatch, + } = useAddPatch(path); const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( null, @@ -243,6 +247,31 @@ export function FileField({ path }: { path: SourcePath }) { ) : []; const disabled = remoteFileUploadDisabled || missingModules.length > 0; + const acceptOptions = useMemo(() => { + if ( + schemaAtPath.data.type !== "file" || + !schemaAtPath.data.moduleMetadata || + schemas.status !== "success" + ) { + return undefined; + } + if (schemaAtPath.data.options?.accept) { + return schemaAtPath.data.options.accept; + } + const modulePaths = Object.keys(schemaAtPath.data.moduleMetadata); + if (modulePaths.length > 1) { + console.error( + `Expected at most 1 referenced module, but got ${modulePaths.length}: ${modulePaths.join(", ")}`, + ); + } + const [modulePath] = modulePaths; + if (!modulePath) return undefined; + const moduleSchema = schemas.data[modulePath as ModuleFilePath]; + if (moduleSchema?.type === "record" && moduleSchema.accept) { + return moduleSchema.accept; + } + return undefined; + }, [schemaAtPath.data, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -404,7 +433,7 @@ export function FileField({ path }: { path: SourcePath }) { hidden id={`file_input:${path}`} type="file" - accept={schemaAtPath.data.options?.accept} + accept={acceptOptions} onChange={(ev) => { readFile(ev).then((res) => { const type = "file"; diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index 8a12ef4b2..78cfc42bb 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -27,7 +27,7 @@ import { PreviewLoading, PreviewNull } from "../../components/Preview"; import { readImage } from "../../utils/readImage"; import { createFilePatch } from "./FileField"; import { ValidationErrors } from "../../components/ValidationError"; -import { useEffect, useState } from "react"; +import { useEffect, useMemo, useState } from "react"; import { Input } from "../designSystem/input"; import { Loader2 } from "lucide-react"; import { Button } from "../designSystem/button"; @@ -54,8 +54,12 @@ export function ImageField({ path }: { path: SourcePath }) { const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< string | null >(null); - const { addPatch, patchPath, addAndUploadPatchWithFileOps, addModuleFilePatch } = - useAddPatch(path); + const { + addPatch, + patchPath, + addAndUploadPatchWithFileOps, + addModuleFilePatch, + } = useAddPatch(path); const portalContainer = useValPortal(); const [progressPercentage, setProgressPercentage] = useState( null, @@ -182,6 +186,31 @@ export function ImageField({ path }: { path: SourcePath }) { ) : []; const disabled = remoteFileUploadDisabled || missingModules.length > 0; + const acceptOptions = useMemo(() => { + if ( + schemaAtPath.data.type !== "image" || + !schemaAtPath.data.moduleMetadata || + schemas.status !== "success" + ) { + return undefined; + } + if (schemaAtPath.data.options?.accept) { + return schemaAtPath.data.options.accept; + } + const modulePaths = Object.keys(schemaAtPath.data.moduleMetadata); + if (modulePaths.length > 1) { + console.error( + `Expected at most 1 referenced module, but got ${modulePaths.length}: ${modulePaths.join(", ")}`, + ); + } + const [modulePath] = modulePaths; + if (!modulePath) return undefined; + const moduleSchema = schemas.data[modulePath as ModuleFilePath]; + if (moduleSchema?.type === "record" && moduleSchema.accept) { + return moduleSchema.accept; + } + return undefined; + }, [schemaAtPath.data, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -407,7 +436,7 @@ export function ImageField({ path }: { path: SourcePath }) { hidden id={`img_input:${path}`} type="file" - accept={schemaAtPath.data.options?.accept || "image/*"} + accept={acceptOptions ?? "image/*"} onChange={(ev) => { readImage(ev).then((res) => { const type = "image"; From ea7252003e07369cb8229dfe2be6eca66bb11ddb Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 27 Feb 2026 16:54:33 +0000 Subject: [PATCH 19/32] Refactor file and image schemas to use referencedModule instead of moduleMetadata; update MediaPicker integration in FileField and ImageField components. --- packages/core/src/schema/file.ts | 11 ++- packages/core/src/schema/image.ts | 11 ++- packages/react/src/stega/stegaEncode.ts | 98 ++++++++++++++++++- .../components/MediaPicker/MediaPicker.tsx | 16 +++ .../ui/spa/components/fields/FileField.tsx | 69 +++---------- .../ui/spa/components/fields/ImageField.tsx | 69 +++---------- 6 files changed, 154 insertions(+), 120 deletions(-) diff --git a/packages/core/src/schema/file.ts b/packages/core/src/schema/file.ts index be0980787..523efa043 100644 --- a/packages/core/src/schema/file.ts +++ b/packages/core/src/schema/file.ts @@ -28,7 +28,7 @@ export type SerializedFileSchema = { remote?: boolean; opt: boolean; customValidate?: boolean; - moduleMetadata?: Record>; + referencedModule?: string; }; export type FileMetadata = { @@ -324,6 +324,9 @@ export class FileSchema< } protected executeSerialize(): SerializedSchema { + const modulePaths = this.moduleMetadata + ? Object.keys(this.moduleMetadata) + : []; return { type: "file", options: this.options, @@ -332,10 +335,8 @@ export class FileSchema< customValidate: this.customValidateFunctions && this.customValidateFunctions?.length > 0, - moduleMetadata: - this.moduleMetadata && Object.keys(this.moduleMetadata).length > 0 - ? this.moduleMetadata - : undefined, + referencedModule: + modulePaths.length > 0 ? (modulePaths[0] as string) : undefined, }; } diff --git a/packages/core/src/schema/image.ts b/packages/core/src/schema/image.ts index 3373d903b..24555b36d 100644 --- a/packages/core/src/schema/image.ts +++ b/packages/core/src/schema/image.ts @@ -32,7 +32,7 @@ export type SerializedImageSchema = { opt: boolean; remote?: boolean; customValidate?: boolean; - moduleMetadata?: Record>; + referencedModule?: string; }; export type ImageMetadata = { @@ -357,6 +357,9 @@ export class ImageSchema< } protected executeSerialize(): SerializedSchema { + const modulePaths = this.moduleMetadata + ? Object.keys(this.moduleMetadata) + : []; return { type: "image", options: this.options, @@ -365,10 +368,8 @@ export class ImageSchema< customValidate: this.customValidateFunctions && this.customValidateFunctions?.length > 0, - moduleMetadata: - this.moduleMetadata && Object.keys(this.moduleMetadata).length > 0 - ? this.moduleMetadata - : undefined, + referencedModule: + modulePaths.length > 0 ? (modulePaths[0] as string) : undefined, }; } diff --git a/packages/react/src/stega/stegaEncode.ts b/packages/react/src/stega/stegaEncode.ts index 3df9dd2d5..97854d7f8 100644 --- a/packages/react/src/stega/stegaEncode.ts +++ b/packages/react/src/stega/stegaEncode.ts @@ -10,6 +10,8 @@ import { SerializedObjectSchema, SerializedUnionSchema, SerializedLiteralSchema, + SerializedFileSchema, + SerializedImageSchema, ImageMetadata, FileMetadata, RichTextOptions, @@ -417,14 +419,30 @@ export function stegaEncode( sourceOrSelector[VAL_EXTENSION] === "file" && typeof sourceOrSelector[FILE_REF_PROP] === "string" ) { - const fileSelector = Internal.convertFileSource(sourceOrSelector); + const source = + recOpts?.schema && opts.getModule + ? augmentWithReferencedModuleMetadata( + sourceOrSelector, + recOpts.schema, + opts.getModule, + ) + : sourceOrSelector; + const fileSelector = Internal.convertFileSource(source); const url = fileSelector.url; return { ...fileSelector, url: rec(url, recOpts), }; } else if (sourceOrSelector[VAL_EXTENSION] === "remote") { - const remoteSelector = Internal.convertFileSource(sourceOrSelector); + const source = + recOpts?.schema && opts.getModule + ? augmentWithReferencedModuleMetadata( + sourceOrSelector, + recOpts.schema, + opts.getModule, + ) + : sourceOrSelector; + const remoteSelector = Internal.convertFileSource(source); const url = remoteSelector.url; return { ...remoteSelector, @@ -556,6 +574,75 @@ function isObjectSchema( return schema?.type === "object"; } +function isFileSchema( + schema: SerializedSchema | undefined, +): schema is SerializedFileSchema { + return schema?.type === "file"; +} + +function isImageSchema( + schema: SerializedSchema | undefined, +): schema is SerializedImageSchema { + return schema?.type === "image"; +} + +function augmentWithReferencedModuleMetadata( + source: any, + schema: SerializedSchema, + getModule: (path: string) => any, +): any { + if ( + source.metadata || + !(isFileSchema(schema) || isImageSchema(schema)) || + !schema.referencedModule + ) { + return source; + } + const moduleSource = getModule(schema.referencedModule); + if ( + !moduleSource || + typeof moduleSource !== "object" || + Array.isArray(moduleSource) + ) { + return source; + } + const ref: string = source[FILE_REF_PROP]; + // For local files the ref is the file path directly; for remote refs we + // need to extract the file path from the remote URL. + let fileRef: string | null = ref in moduleSource ? ref : null; + if (!fileRef) { + const splitResult = Internal.remote.splitRemoteRef(ref); + if (splitResult.status === "success" && splitResult.filePath in moduleSource) { + fileRef = splitResult.filePath; + } + } + if (!fileRef) { + return source; + } + return { ...source, metadata: moduleSource[fileRef] }; +} + +function collectReferencedModulesFromSchema( + schema: SerializedSchema, + acc: Set, +): void { + if (isFileSchema(schema) || isImageSchema(schema)) { + if (schema.referencedModule) { + acc.add(schema.referencedModule); + } + } else if (schema.type === "object") { + for (const v of Object.values(schema.items)) { + collectReferencedModulesFromSchema(v, acc); + } + } else if (schema.type === "array" || schema.type === "record") { + collectReferencedModulesFromSchema(schema.item, acc); + } else if (schema.type === "union") { + for (const item of schema.items) { + collectReferencedModulesFromSchema(item, acc); + } + } +} + export function stegaClean(source: string) { return vercelStegaSplit(source).cleaned; } @@ -570,6 +657,13 @@ export function getModuleIds(input: any): string[] { const selectorPath = Internal.getValPath(sourceOrSelector); if (selectorPath) { modules.add(selectorPath); + const schema = Internal.getSchema(sourceOrSelector); + if (schema) { + const serialized = schema["executeSerialize"](); + if (serialized) { + collectReferencedModulesFromSchema(serialized, modules); + } + } return; } diff --git a/packages/ui/spa/components/MediaPicker/MediaPicker.tsx b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx index ca6d8d0d2..c8919605e 100644 --- a/packages/ui/spa/components/MediaPicker/MediaPicker.tsx +++ b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx @@ -9,6 +9,8 @@ import { Button } from "../designSystem/button"; import { cn } from "../designSystem/cn"; import { Check, ChevronsUpDown, ImageIcon, FileIcon, Search } from "lucide-react"; import { prettyModuleName } from "./GalleryUploadTarget"; +import { ModuleFilePath } from "@valbuild/core"; +import { useSourceAtPath } from "../ValFieldProvider"; export interface GalleryEntry { /** The file path key (e.g. "/public/val/images/logo.png") */ @@ -350,3 +352,17 @@ export function MediaPicker({ ); } + +export function ModuleMediaPicker({ + modulePath, + ...rest +}: Omit & { modulePath: ModuleFilePath }) { + const source = useSourceAtPath(modulePath); + if (source.status !== "success") { + return null; + } + const moduleEntries = { + [modulePath]: source.data as Record>, + }; + return ; +} diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index 80c401157..327d010b1 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -37,9 +37,8 @@ import { useMemo, useState } from "react"; import { getFileExt } from "../../utils/getFileExt"; import { useEffect } from "react"; import { useValPortal } from "../ValPortalProvider"; -import { MediaPicker } from "../MediaPicker/MediaPicker"; +import { ModuleMediaPicker } from "../MediaPicker/MediaPicker"; import type { GalleryEntry } from "../MediaPicker/MediaPicker"; -import { GalleryUploadTarget } from "../MediaPicker/GalleryUploadTarget"; const textEncoder = new TextEncoder(); export async function createFilePatch( @@ -125,9 +124,6 @@ export function FileField({ path }: { path: SourcePath }) { const [error, setError] = useState(null); const [url, setUrl] = useState(null); const [loading, setLoading] = useState(false); - const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< - string | null - >(null); const { addPatch, patchPath, @@ -163,18 +159,6 @@ export function FileField({ path }: { path: SourcePath }) { } } }, [sourceAtPath]); - useEffect(() => { - if ( - schemaAtPath.status === "success" && - schemaAtPath.data.type === "file" && - schemaAtPath.data.moduleMetadata - ) { - const keys = Object.keys(schemaAtPath.data.moduleMetadata); - if (keys.length >= 1 && selectedGalleryModulePath === null) { - setSelectedGalleryModulePath(keys[0]); - } - } - }, [schemaAtPath]); useEffect(() => { // We want to show video if only video is accepted // If source is defined we also show a video if the mimeType is video @@ -240,17 +224,18 @@ export function FileField({ path }: { path: SourcePath }) { schemaAtPath.data.type === "file" && schemaAtPath.data.remote && remoteFiles.status !== "ready"; + const referencedModule = schemaAtPath.data.referencedModule; const missingModules = - schemaAtPath.data.moduleMetadata && schemas.status === "success" - ? Object.keys(schemaAtPath.data.moduleMetadata).filter( - (modulePath) => !schemas.data[modulePath as ModuleFilePath], - ) + referencedModule && schemas.status === "success" + ? schemas.data[referencedModule as ModuleFilePath] + ? [] + : [referencedModule] : []; const disabled = remoteFileUploadDisabled || missingModules.length > 0; const acceptOptions = useMemo(() => { if ( schemaAtPath.data.type !== "file" || - !schemaAtPath.data.moduleMetadata || + !referencedModule || schemas.status !== "success" ) { return undefined; @@ -258,20 +243,12 @@ export function FileField({ path }: { path: SourcePath }) { if (schemaAtPath.data.options?.accept) { return schemaAtPath.data.options.accept; } - const modulePaths = Object.keys(schemaAtPath.data.moduleMetadata); - if (modulePaths.length > 1) { - console.error( - `Expected at most 1 referenced module, but got ${modulePaths.length}: ${modulePaths.join(", ")}`, - ); - } - const [modulePath] = modulePaths; - if (!modulePath) return undefined; - const moduleSchema = schemas.data[modulePath as ModuleFilePath]; + const moduleSchema = schemas.data[referencedModule as ModuleFilePath]; if (moduleSchema?.type === "record" && moduleSchema.accept) { return moduleSchema.accept; } return undefined; - }, [schemaAtPath.data, schemas]); + }, [schemaAtPath.data, referencedModule, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -336,24 +313,9 @@ export function FileField({ path }: { path: SourcePath }) { )}
)} - {schemaAtPath.data.moduleMetadata && - Object.keys(schemaAtPath.data.moduleMetadata).length > 1 && ( - - )} - {schemaAtPath.data.moduleMetadata && - Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( - > - > - } + {referencedModule && ( + { addPatch( @@ -449,7 +411,6 @@ export function FileField({ path }: { path: SourcePath }) { }; } setError(null); - const hasGallery = selectedGalleryModulePath !== null; createFilePatch( patchPath, data.src, @@ -459,7 +420,7 @@ export function FileField({ path }: { path: SourcePath }) { type, remoteData, config.files?.directory, - hasGallery, + false, ) .then(({ patch, filePath }) => { setLoading(true); @@ -485,12 +446,12 @@ export function FileField({ path }: { path: SourcePath }) { .then(() => { if ( !hasError && - selectedGalleryModulePath && + referencedModule && filePath && metadata?.mimeType ) { addModuleFilePatch( - selectedGalleryModulePath as ModuleFilePath, + referencedModule as ModuleFilePath, [ { op: "add", diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index 78cfc42bb..97a4351a0 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -32,9 +32,8 @@ import { Input } from "../designSystem/input"; import { Loader2 } from "lucide-react"; import { Button } from "../designSystem/button"; import { useValPortal } from "../ValPortalProvider"; -import { MediaPicker } from "../MediaPicker/MediaPicker"; +import { ModuleMediaPicker } from "../MediaPicker/MediaPicker"; import type { GalleryEntry } from "../MediaPicker/MediaPicker"; -import { GalleryUploadTarget } from "../MediaPicker/GalleryUploadTarget"; import { JSONValue } from "@valbuild/core/patch"; export function ImageField({ path }: { path: SourcePath }) { @@ -51,9 +50,6 @@ export function ImageField({ path }: { path: SourcePath }) { const [error, setError] = useState(null); const [url, setUrl] = useState(null); const [loading, setLoading] = useState(false); - const [selectedGalleryModulePath, setSelectedGalleryModulePath] = useState< - string | null - >(null); const { addPatch, patchPath, @@ -67,18 +63,6 @@ export function ImageField({ path }: { path: SourcePath }) { const maybeSourceData = "data" in sourceAtPath && sourceAtPath.data; const maybeClientSideOnly = sourceAtPath.status === "success" && sourceAtPath.clientSideOnly; - useEffect(() => { - if ( - schemaAtPath.status === "success" && - schemaAtPath.data.type === "image" && - schemaAtPath.data.moduleMetadata - ) { - const keys = Object.keys(schemaAtPath.data.moduleMetadata); - if (keys.length >= 1 && selectedGalleryModulePath === null) { - setSelectedGalleryModulePath(keys[0]); - } - } - }, [schemaAtPath]); useEffect(() => { if (maybeSourceData) { if (maybeSourceData.metadata) { @@ -179,17 +163,18 @@ export function ImageField({ path }: { path: SourcePath }) { schemaAtPath.data.type === "image" && schemaAtPath.data.remote && remoteFiles.status !== "ready"; + const referencedModule = schemaAtPath.data.referencedModule; const missingModules = - schemaAtPath.data.moduleMetadata && schemas.status === "success" - ? Object.keys(schemaAtPath.data.moduleMetadata).filter( - (modulePath) => !schemas.data[modulePath as ModuleFilePath], - ) + referencedModule && schemas.status === "success" + ? schemas.data[referencedModule as ModuleFilePath] + ? [] + : [referencedModule] : []; const disabled = remoteFileUploadDisabled || missingModules.length > 0; const acceptOptions = useMemo(() => { if ( schemaAtPath.data.type !== "image" || - !schemaAtPath.data.moduleMetadata || + !referencedModule || schemas.status !== "success" ) { return undefined; @@ -197,20 +182,12 @@ export function ImageField({ path }: { path: SourcePath }) { if (schemaAtPath.data.options?.accept) { return schemaAtPath.data.options.accept; } - const modulePaths = Object.keys(schemaAtPath.data.moduleMetadata); - if (modulePaths.length > 1) { - console.error( - `Expected at most 1 referenced module, but got ${modulePaths.length}: ${modulePaths.join(", ")}`, - ); - } - const [modulePath] = modulePaths; - if (!modulePath) return undefined; - const moduleSchema = schemas.data[modulePath as ModuleFilePath]; + const moduleSchema = schemas.data[referencedModule as ModuleFilePath]; if (moduleSchema?.type === "record" && moduleSchema.accept) { return moduleSchema.accept; } return undefined; - }, [schemaAtPath.data, schemas]); + }, [schemaAtPath.data, referencedModule, schemas]); const remoteData = schemaAtPath.data.remote && remoteFiles.status === "ready" && @@ -387,24 +364,9 @@ export function ImageField({ path }: { path: SourcePath }) { )}
)} - {schemaAtPath.data.moduleMetadata && - Object.keys(schemaAtPath.data.moduleMetadata).length > 1 && ( - - )} - {schemaAtPath.data.moduleMetadata && - Object.keys(schemaAtPath.data.moduleMetadata).length > 0 && ( - > - > - } + {referencedModule && ( + { addPatch( @@ -459,7 +421,6 @@ export function ImageField({ path }: { path: SourcePath }) { }; } setError(null); - const hasGallery = selectedGalleryModulePath !== null; createFilePatch( patchPath, data.src, @@ -469,7 +430,7 @@ export function ImageField({ path }: { path: SourcePath }) { type, remoteData, config.files?.directory, - hasGallery, + false, ) .then(({ patch, filePath }) => { setLoading(true); @@ -493,14 +454,14 @@ export function ImageField({ path }: { path: SourcePath }) { .then(() => { if ( !hasError && - selectedGalleryModulePath && + referencedModule && filePath && metadata?.mimeType && metadata.width !== undefined && metadata.height !== undefined ) { addModuleFilePatch( - selectedGalleryModulePath as ModuleFilePath, + referencedModule as ModuleFilePath, [ { op: "add", From 98cd3c2dc052440ee01dfb4f583cdcaf1156bd84 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 27 Feb 2026 16:54:52 +0000 Subject: [PATCH 20/32] Add useFilePatchIds hook and integrate it into FileField and ImageField components for patch management --- .../ui/spa/components/ValFieldProvider.tsx | 22 +++++++++++++++++++ .../ui/spa/components/fields/FileField.tsx | 7 +++++- .../ui/spa/components/fields/ImageField.tsx | 7 +++++- 3 files changed, 34 insertions(+), 2 deletions(-) diff --git a/packages/ui/spa/components/ValFieldProvider.tsx b/packages/ui/spa/components/ValFieldProvider.tsx index c3f32348a..067bc3366 100644 --- a/packages/ui/spa/components/ValFieldProvider.tsx +++ b/packages/ui/spa/components/ValFieldProvider.tsx @@ -1016,4 +1016,26 @@ export function useSourceAtPath(sourcePath: SourcePath | ModuleFilePath): }, [sourceSnapshot, initializedAt, modulePath, moduleFilePath]); } +export function useFilePatchIds(): ReadonlyMap { + const { syncEngine } = useContext(ValFieldContext); + const patchesSnapshot = useSyncExternalStore( + syncEngine.subscribe("all-patches"), + () => syncEngine.getAllPatchesSnapshot(), + () => syncEngine.getAllPatchesSnapshot(), + ); + return useMemo(() => { + const map = new Map(); + for (const [patchId, data] of Object.entries(patchesSnapshot ?? {})) { + if (data && !data.isCommitted) { + for (const op of data.patch) { + if (op.op === "file" && "filePath" in op) { + map.set(op.filePath as string, patchId); + } + } + } + } + return map; + }, [patchesSnapshot]); +} + export type { ShallowSource }; diff --git a/packages/ui/spa/components/fields/FileField.tsx b/packages/ui/spa/components/fields/FileField.tsx index 327d010b1..ed716fa8b 100644 --- a/packages/ui/spa/components/fields/FileField.tsx +++ b/packages/ui/spa/components/fields/FileField.tsx @@ -24,6 +24,7 @@ import { useShallowSourceAtPath, useAddPatch, useSchemas, + useFilePatchIds, } from "../ValFieldProvider"; import { useCurrentRemoteFileBucket, @@ -134,6 +135,7 @@ export function FileField({ path }: { path: SourcePath }) { const [progressPercentage, setProgressPercentage] = useState( null, ); + const filePatchIds = useFilePatchIds(); const maybeSourceData = "data" in sourceAtPath && sourceAtPath.data; const maybeClientSideOnly = sourceAtPath.status === "success" && sourceAtPath.clientSideOnly; @@ -142,23 +144,26 @@ export function FileField({ path }: { path: SourcePath }) { if (maybeSourceData.metadata) { // We can't set the url before it is server side (since the we will be loading) if (!maybeClientSideOnly) { + const patchId = filePatchIds.get(maybeSourceData[FILE_REF_PROP]); const nextUrl = VAL_EXTENSION in maybeSourceData && maybeSourceData[VAL_EXTENSION] === "remote" ? Internal.convertRemoteSource({ ...maybeSourceData, [VAL_EXTENSION]: "remote", + ...(patchId ? { patch_id: patchId } : {}), }).url : Internal.convertFileSource({ ...maybeSourceData, [VAL_EXTENSION]: "file", + ...(patchId ? { patch_id: patchId } : {}), }).url; setUrl(nextUrl); setLoading(false); } } } - }, [sourceAtPath]); + }, [sourceAtPath, filePatchIds]); useEffect(() => { // We want to show video if only video is accepted // If source is defined we also show a video if the mimeType is video diff --git a/packages/ui/spa/components/fields/ImageField.tsx b/packages/ui/spa/components/fields/ImageField.tsx index 97a4351a0..e8392f65c 100644 --- a/packages/ui/spa/components/fields/ImageField.tsx +++ b/packages/ui/spa/components/fields/ImageField.tsx @@ -17,6 +17,7 @@ import { useAddPatch, useValConfig, useSchemas, + useFilePatchIds, } from "../ValFieldProvider"; import { useCurrentRemoteFileBucket, @@ -60,6 +61,7 @@ export function ImageField({ path }: { path: SourcePath }) { const [progressPercentage, setProgressPercentage] = useState( null, ); + const filePatchIds = useFilePatchIds(); const maybeSourceData = "data" in sourceAtPath && sourceAtPath.data; const maybeClientSideOnly = sourceAtPath.status === "success" && sourceAtPath.clientSideOnly; @@ -68,16 +70,19 @@ export function ImageField({ path }: { path: SourcePath }) { if (maybeSourceData.metadata) { // We can't set the url before it is server side (since the we will be loading) if (!maybeClientSideOnly) { + const patchId = filePatchIds.get(maybeSourceData[FILE_REF_PROP]); const nextUrl = VAL_EXTENSION in maybeSourceData && maybeSourceData[VAL_EXTENSION] === "remote" ? Internal.convertRemoteSource({ ...maybeSourceData, [VAL_EXTENSION]: "remote", + ...(patchId ? { patch_id: patchId } : {}), }).url : Internal.convertFileSource({ ...maybeSourceData, [VAL_EXTENSION]: "file", + ...(patchId ? { patch_id: patchId } : {}), }).url; setUrl(nextUrl); setLoading(false); @@ -119,7 +124,7 @@ export function ImageField({ path }: { path: SourcePath }) { setHotspot(undefined); } } - }, [sourceAtPath]); + }, [sourceAtPath, filePatchIds]); if (schemaAtPath.status === "error") { return ( From dd1b12941b082c49a75c3f539a5dec053bc064bb Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Fri, 27 Feb 2026 16:55:46 +0000 Subject: [PATCH 21/32] Fix urls in media picker used in ImageField and FileField --- .../components/MediaPicker/MediaPicker.tsx | 52 +++++++++++++++---- 1 file changed, 43 insertions(+), 9 deletions(-) diff --git a/packages/ui/spa/components/MediaPicker/MediaPicker.tsx b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx index c8919605e..943195c13 100644 --- a/packages/ui/spa/components/MediaPicker/MediaPicker.tsx +++ b/packages/ui/spa/components/MediaPicker/MediaPicker.tsx @@ -7,10 +7,16 @@ import { } from "../designSystem/popover"; import { Button } from "../designSystem/button"; import { cn } from "../designSystem/cn"; -import { Check, ChevronsUpDown, ImageIcon, FileIcon, Search } from "lucide-react"; +import { + Check, + ChevronsUpDown, + ImageIcon, + FileIcon, + Search, +} from "lucide-react"; import { prettyModuleName } from "./GalleryUploadTarget"; import { ModuleFilePath } from "@valbuild/core"; -import { useSourceAtPath } from "../ValFieldProvider"; +import { useFilePatchIds, useSourceAtPath } from "../ValFieldProvider"; export interface GalleryEntry { /** The file path key (e.g. "/public/val/images/logo.png") */ @@ -33,6 +39,8 @@ export interface MediaPickerProps { disabled?: boolean; /** Portal container for the popover (shadow DOM support) */ portalContainer?: HTMLElement | null; + /** Converts a gallery file path to a displayable URL (e.g. for patch-state files) */ + getUrl?: (filePath: string) => string; } const ROW_HEIGHT = 48; @@ -40,7 +48,12 @@ const ROW_HEIGHT = 48; /** A flat row for the virtualized list. Can be a heading or an entry. */ type PickerRow = | { kind: "heading"; modulePath: string } - | { kind: "entry"; filePath: string; metadata: Record; modulePath: string }; + | { + kind: "entry"; + filePath: string; + metadata: Record; + modulePath: string; + }; function buildRows( moduleEntries: Record>>, @@ -89,6 +102,7 @@ export function MediaPicker({ isImage = false, disabled = false, portalContainer, + getUrl, }: MediaPickerProps) { const [open, setOpen] = React.useState(false); const [filter, setFilter] = React.useState(""); @@ -279,8 +293,7 @@ export function MediaPicker({ ); } - const filename = - row.filePath.split("/").pop() || row.filePath; + const filename = row.filePath.split("/").pop() || row.filePath; const isSelected = selectedRef === row.filePath; const isActive = virtualRow.index === activeIndex; const alt = @@ -316,9 +329,11 @@ export function MediaPicker({
{alt & { modulePath: ModuleFilePath }) { const source = useSourceAtPath(modulePath); + const filePatchIds = useFilePatchIds(); + + const getUrl = React.useCallback( + (filePath: string): string => { + const patchId = filePatchIds.get(filePath); + if (patchId) { + return filePath.startsWith("/public") + ? `/api/val/files${filePath}?patch_id=${patchId}` + : `${filePath}?patch_id=${patchId}`; + } + return filePath.startsWith("/public") + ? filePath.slice("/public".length) + : filePath; + }, + [filePatchIds], + ); + if (source.status !== "success") { return null; } const moduleEntries = { [modulePath]: source.data as Record>, }; - return ; + return ( + + ); } From fdc5c9520741ba94de13e8f722817b2c4632514e Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Sat, 28 Feb 2026 11:46:59 +0100 Subject: [PATCH 22/32] Fix open file properties in file gallery --- .../components/FileGallery/FileGallery.tsx | 30 ++- .../FileGallery/FilePropertiesModal.tsx | 4 +- .../ui/spa/components/FileGallery/types.ts | 2 + .../spa/components/fields/ModuleGallery.tsx | 215 ++++++++++++++++++ .../ui/spa/components/fields/RecordFields.tsx | 4 + 5 files changed, 253 insertions(+), 2 deletions(-) create mode 100644 packages/ui/spa/components/fields/ModuleGallery.tsx diff --git a/packages/ui/spa/components/FileGallery/FileGallery.tsx b/packages/ui/spa/components/FileGallery/FileGallery.tsx index 716d30bd1..e8911d6ac 100644 --- a/packages/ui/spa/components/FileGallery/FileGallery.tsx +++ b/packages/ui/spa/components/FileGallery/FileGallery.tsx @@ -1,11 +1,20 @@ import * as React from "react"; -import { FolderOpen, Grid, LayoutGrid, List, Search } from "lucide-react"; +import { + FolderOpen, + Grid, + LayoutGrid, + List, + Loader2, + Plus, + Search, +} from "lucide-react"; import { cn } from "../designSystem/cn"; import { Input } from "../designSystem/input"; import { Skeleton } from "../designSystem/skeleton"; import { FileGalleryItem } from "./FileGalleryItem"; import { FileGalleryListView } from "./FileGalleryListView"; import { FilePropertiesModal } from "./FilePropertiesModal"; +import { useValPortal } from "../ValPortalProvider"; import type { FileGalleryProps, SortDirection, @@ -23,7 +32,10 @@ export function FileGallery({ imageMode = false, loading = false, disabled = false, + onUploadClick, + uploading = false, }: FileGalleryProps) { + const portalContainer = useValPortal(); const [selectedIndex, setSelectedIndex] = React.useState(null); const [isPropertiesOpen, setIsPropertiesOpen] = React.useState(false); const [viewMode, setViewMode] = React.useState(defaultViewMode); @@ -147,6 +159,21 @@ export function FileGallery({
)}
+ {onUploadClick && ( + + )}
); diff --git a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx index a5b89f220..4f442a181 100644 --- a/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx +++ b/packages/ui/spa/components/FileGallery/FilePropertiesModal.tsx @@ -22,6 +22,7 @@ interface FilePropertiesModalProps { imageMode?: boolean; loading?: boolean; disabled?: boolean; + container?: HTMLElement | null; } export function FilePropertiesModal({ @@ -34,6 +35,7 @@ export function FilePropertiesModal({ imageMode, loading, disabled, + container, }: FilePropertiesModalProps) { const [isEditingAlt, setIsEditingAlt] = React.useState(false); const [editedAlt, setEditedAlt] = React.useState(""); @@ -75,7 +77,7 @@ export function FilePropertiesModal({ return ( - + File Properties diff --git a/packages/ui/spa/components/FileGallery/types.ts b/packages/ui/spa/components/FileGallery/types.ts index c3bbbf2ad..dc642d20d 100644 --- a/packages/ui/spa/components/FileGallery/types.ts +++ b/packages/ui/spa/components/FileGallery/types.ts @@ -29,4 +29,6 @@ export interface FileGalleryProps { imageMode?: boolean; loading?: boolean; disabled?: boolean; + onUploadClick?: () => void; + uploading?: boolean; } diff --git a/packages/ui/spa/components/fields/ModuleGallery.tsx b/packages/ui/spa/components/fields/ModuleGallery.tsx new file mode 100644 index 000000000..aadd137f4 --- /dev/null +++ b/packages/ui/spa/components/fields/ModuleGallery.tsx @@ -0,0 +1,215 @@ +import * as React from "react"; +import { FileMetadata, ImageMetadata, Internal, SourcePath } from "@valbuild/core"; +import { JSONValue, Patch } from "@valbuild/core/patch"; +import { + useAddPatch, + useFilePatchIds, + useSchemaAtPath, + useSourceAtPath, + useValConfig, +} from "../ValFieldProvider"; +import { ValidationErrors } from "../ValidationError"; +import { FieldLoading } from "../FieldLoading"; +import { FileGallery } from "../FileGallery/FileGallery"; +import type { GalleryFile } from "../FileGallery/types"; +import { readImage } from "../../utils/readImage"; +import { readFile } from "../../utils/readFile"; + +function refToUrl( + filePath: string, + filePatchIds: ReadonlyMap, +): string { + const patchId = filePatchIds.get(filePath); + if (patchId) { + return filePath.startsWith("/public") + ? `/api/val/files${filePath}?patch_id=${patchId}` + : `${filePath}?patch_id=${patchId}`; + } + return filePath.startsWith("/public") + ? filePath.slice("/public".length) + : filePath; +} + +export function ModuleGallery({ path }: { path: SourcePath }) { + const source = useSourceAtPath(path); + const schemaAtPath = useSchemaAtPath(path); + const filePatchIds = useFilePatchIds(); + const config = useValConfig(); + const { addPatch, patchPath, addAndUploadPatchWithFileOps } = + useAddPatch(path); + + const inputRef = React.useRef(null); + const [uploading, setUploading] = React.useState(false); + const [uploadError, setUploadError] = React.useState(null); + + const rawSource = + source.status === "success" + ? (source.data as Record> | null) + : null; + + const schema = + schemaAtPath.status === "success" && schemaAtPath.data.type === "record" + ? schemaAtPath.data + : null; + + const imageMode = schema?.mediaType === "images"; + const directory = + schema?.directory ?? config?.files?.directory ?? "/public/val"; + const accept = schema?.accept; + + const files: GalleryFile[] = rawSource + ? Object.entries(rawSource).map(([ref, meta]) => { + const mimeType = + typeof meta.mimeType === "string" ? meta.mimeType : ""; + const width = typeof meta.width === "number" ? meta.width : 0; + const height = typeof meta.height === "number" ? meta.height : 0; + const alt = typeof meta.alt === "string" ? meta.alt : undefined; + return { + url: refToUrl(ref, filePatchIds), + filename: ref.split("/").pop() || ref, + folder: ref.substring(0, ref.lastIndexOf("/")), + metadata: { mimeType, width, height, alt }, + }; + }) + : []; + + const handleAltTextChange = React.useCallback( + (index: number, newAltText: string) => { + if (!rawSource) return; + const ref = Object.keys(rawSource)[index]; + if (!ref) return; + const patch: Patch = [ + { + op: "replace", + path: [...patchPath, ref, "alt"], + value: newAltText || null, + }, + ]; + addPatch(patch, "record"); + }, + [rawSource, patchPath, addPatch], + ); + + const handleUpload = React.useCallback( + (ev: React.ChangeEvent) => { + setUploadError(null); + if (imageMode) { + readImage(ev) + .then(async (res) => { + if (!res.width || !res.height || !res.mimeType) return; + const metadata: ImageMetadata = { + width: res.width, + height: res.height, + mimeType: res.mimeType, + }; + const newFilename = Internal.createFilename( + res.src, + res.filename ?? null, + metadata, + res.fileHash, + ); + if (!newFilename) return; + const filePath = `${directory}/${newFilename}`; + const patch: Patch = [ + { + op: "add", + path: [...patchPath, filePath], + value: { + width: metadata.width, + height: metadata.height, + mimeType: metadata.mimeType, + alt: null, // default alt for new uploads + } as JSONValue, + }, + { + op: "file", + path: [...patchPath, filePath], + filePath, + value: res.src, + metadata, + remote: false, + }, + ]; + setUploading(true); + await addAndUploadPatchWithFileOps( + patch, + "image", + (msg) => setUploadError(msg), + () => {}, + ); + }) + .catch(() => setUploadError("Could not upload image. Please try again.")) + .finally(() => setUploading(false)); + } else { + readFile(ev) + .then(async (res) => { + if (!res.mimeType) return; + const metadata: FileMetadata = { mimeType: res.mimeType }; + const newFilename = Internal.createFilename( + res.src, + res.filename ?? null, + metadata, + res.fileHash, + ); + if (!newFilename) return; + const filePath = `${directory}/${newFilename}`; + const patch: Patch = [ + { + op: "add", + path: [...patchPath, filePath], + value: { mimeType: metadata.mimeType } as JSONValue, + }, + { + op: "file", + path: [...patchPath, filePath], + filePath, + value: res.src, + metadata, + remote: false, + }, + ]; + setUploading(true); + await addAndUploadPatchWithFileOps( + patch, + "file", + (msg) => setUploadError(msg), + () => {}, + ); + }) + .catch(() => setUploadError("Could not upload file. Please try again.")) + .finally(() => setUploading(false)); + } + ev.target.value = ""; + }, + [imageMode, directory, patchPath, addAndUploadPatchWithFileOps], + ); + + if (source.status !== "success") { + return ; + } + + return ( +
+ + {uploadError && ( +
+ {uploadError} +
+ )} + + inputRef.current?.click()} + uploading={uploading} + /> +
+ ); +} diff --git a/packages/ui/spa/components/fields/RecordFields.tsx b/packages/ui/spa/components/fields/RecordFields.tsx index a7c30d0ef..038b97903 100644 --- a/packages/ui/spa/components/fields/RecordFields.tsx +++ b/packages/ui/spa/components/fields/RecordFields.tsx @@ -7,6 +7,7 @@ import { useSchemaAtPath, useShallowSourceAtPath, } from "../ValFieldProvider"; +import { ModuleGallery } from "./ModuleGallery"; import { useAllValidationErrors } from "../ValErrorProvider"; import { sourcePathOfItem } from "../../utils/sourcePathOfItem"; import { FieldLoading } from "../../components/FieldLoading"; @@ -65,6 +66,9 @@ export function RecordFields({ path }: { path: SourcePath }) { /> ); } + if (schemaAtPath.data.mediaType) { + return ; + } const source = sourceAtPath.data; const renderListAtPathData = renderAtPath && From 5d36bd42d70e0fb91ccdd29abecf91cae99abf65 Mon Sep 17 00:00:00 2001 From: Fredrik Ekholdt Date: Sun, 1 Mar 2026 12:10:25 +0100 Subject: [PATCH 23/32] Fix file module gallery --- examples/next/content/media.val.ts | 2 +- packages/core/src/schema/images.ts | 9 +- packages/core/src/schema/string.ts | 10 ++ packages/server/src/ValOps.ts | 67 +++++---- packages/server/src/ValOpsFS.ts | 21 ++- packages/server/src/ValOpsHttp.ts | 4 +- packages/server/src/ValServer.ts | 2 + packages/server/src/patch/ts/ops.ts | 6 +- packages/ui/spa/components/Field.tsx | 17 ++- .../components/FileGallery/FileGallery.tsx | 34 +++-- .../FileGallery/FileGalleryItem.tsx | 13 +- .../FileGallery/FileGalleryListView.tsx | 135 +++++++++++++----- .../FileGallery/FilePropertiesModal.tsx | 126 +++++++--------- .../stories/FileGallery.stories.tsx | 11 ++ .../ui/spa/components/FileGallery/types.ts | 6 +- packages/ui/spa/components/Module.tsx | 9 +- .../ui/spa/components/designSystem/input.tsx | 2 +- .../ui/spa/components/fields/FileField.tsx | 12 +- .../ui/spa/components/fields/ImageField.tsx | 55 +++---- .../spa/components/fields/ModuleGallery.tsx | 85 +++++++++-- packages/ui/spa/hooks/useParent.ts | 3 +- 21 files changed, 406 insertions(+), 223 deletions(-) diff --git a/examples/next/content/media.val.ts b/examples/next/content/media.val.ts index d7792cb1f..ef551bce2 100644 --- a/examples/next/content/media.val.ts +++ b/examples/next/content/media.val.ts @@ -3,7 +3,7 @@ import { c, s } from "../val.config"; export default c.define( "/content/media.val.ts", s.images({ - accept: "image/webp", + accept: "image/*", directory: "/public/val/images", alt: s.string().minLength(4), }), diff --git a/packages/core/src/schema/images.ts b/packages/core/src/schema/images.ts index 3f62268eb..38b308002 100644 --- a/packages/core/src/schema/images.ts +++ b/packages/core/src/schema/images.ts @@ -4,7 +4,6 @@ import { RecordSchema } from "./record"; import { ObjectSchema } from "./object"; import { StringSchema, string } from "./string"; import { NumberSchema } from "./number"; -import { SelectorSource } from "../selector"; /** * Alt schema type - can be a string, nullable string, or a record of locale to string @@ -101,20 +100,20 @@ export const images = ( > => { const directory = options.directory ?? "/public/val"; const altSchema = options.alt ?? string().nullable(); - const itemSchema = new ObjectSchema( + const itemSchema = new ObjectSchema( { width: new NumberSchema(undefined, false), height: new NumberSchema(undefined, false), mimeType: new StringSchema({}, false), - alt: new StringSchema({}, true), + alt: altSchema, }, false, - ); + ) as ObjectSchema; return new RecordSchema(itemSchema, false, [], null, null, { type: "images", accept: options.accept, directory, remote: options.remote ?? false, - altSchema: altSchema as Schema, + altSchema, }); }; diff --git a/packages/core/src/schema/string.ts b/packages/core/src/schema/string.ts index 737020edf..05fce0665 100644 --- a/packages/core/src/schema/string.ts +++ b/packages/core/src/schema/string.ts @@ -115,6 +115,16 @@ export class StringSchema extends Schema { if (this.opt && (src === null || src === undefined)) { return errors.length > 0 ? { [path]: errors } : false; } + if (!this.opt && src === null) { + return { + [path]: [ + { + message: `Expected a non-empty value`, + value: src, + }, + ], + }; + } if (typeof src !== "string") { return { [path]: [ diff --git a/packages/server/src/ValOps.ts b/packages/server/src/ValOps.ts index 04635c911..5bdd9e84c 100644 --- a/packages/server/src/ValOps.ts +++ b/packages/server/src/ValOps.ts @@ -403,6 +403,7 @@ export abstract class ValOps { { patchId: PatchId; remote: boolean; + isDelete: boolean; } > = {}; for (const patch of sortedPatches) { @@ -415,7 +416,9 @@ export abstract class ValOps { fileLastUpdatedByPatchId[filePath] = { patchId: patch.patchId, remote: op.remote, + isDelete: op.value === null, }; + continue; } const path = patch.path; if (!patchesByModule[path]) { @@ -508,19 +511,23 @@ export abstract class ValOps { const fileFixOps: Record = {}; for (const op of patchData.patch) { if (op.op === "file") { - // NOTE: We insert the last patch_id that modify a file - // when constructing the url we use the patch id (and the file path) - // to fetch the right file - // NOTE: overwrite and use last patch_id if multiple patches modify the same file - fileFixOps[op.path.join("/")] = [ - { - op: "add", - path: op.path - .concat(...(op.nestedFilePath || [])) - .concat("patch_id"), - value: patchId, - }, - ]; + if (op.value !== null) { + // NOTE: We insert the last patch_id that modify a file + // when constructing the url we use the patch id (and the file path) + // to fetch the right file + // NOTE: overwrite and use last patch_id if multiple patches modify the same file + fileFixOps[op.path.join("/")] = [ + { + op: "add", + path: op.path + .concat(...(op.nestedFilePath || [])) + .concat("patch_id"), + value: patchId, + }, + ]; + } + // null value = delete: no patch_id to inject; the "remove" op in + // the patch already removes the metadata entry from the source } else { applicableOps.push(op); } @@ -1061,7 +1068,7 @@ export abstract class ValOps { patchAnalysis: PatchAnalysis & OrderedPatches, ): Promise { const { patchesByModule, fileLastUpdatedByPatchId } = patchAnalysis; - const patchedSourceFiles: Record = {}; + const patchedSourceFiles: Record = {}; const previousSourceFiles: Record = {}; const applySourceFilePatches = async ( @@ -1233,15 +1240,20 @@ export abstract class ValOps { await Promise.all( Object.entries(fileLastUpdatedByPatchId).map( async ([filePath, patchData]) => { - const { patchId, remote } = patchData; + const { patchId, remote, isDelete } = patchData; if (globalAppliedPatches.includes(patchId)) { - // TODO: do we want to make sure the file is there? Then again, it should be rare that it happens (unless there's a Val bug) so it might be enough to fail later (at commit) - // TODO: include sha256? This way we can make sure we pick the right file since theoretically there could be multiple files with the same path in the same patch - // or is that the case? We are picking the latest file by path so, that should be enough? - patchedBinaryFilesDescriptors[filePath] = { - patchId, - remote, - }; + if (isDelete) { + // Signal file deletion via patchedSourceFiles null entry + patchedSourceFiles[filePath] = null; + } else { + // TODO: do we want to make sure the file is there? Then again, it should be rare that it happens (unless there's a Val bug) so it might be enough to fail later (at commit) + // TODO: include sha256? This way we can make sure we pick the right file since theoretically there could be multiple files with the same path in the same patch + // or is that the case? We are picking the latest file by path so, that should be enough? + patchedBinaryFilesDescriptors[filePath] = { + patchId, + remote, + }; + } } else { hasErrors = true; binaryFilePatchErrors[filePath] = { @@ -1338,9 +1350,9 @@ export abstract class ValOps { filePath: string, parentRef: ParentRef, patchId: PatchId, - data: string, + data: string | null, type: "file" | "image", - metadata: MetadataOfType<"file" | "image">, + metadata: MetadataOfType<"file" | "image"> | undefined, ): Promise>; abstract getBase64EncodedBinaryFileFromPatch( filePath: string, @@ -1431,7 +1443,7 @@ export type PatchAnalysis = { }; fileLastUpdatedByPatchId: Record< string, - { patchId: PatchId; remote: boolean } + { patchId: PatchId; remote: boolean; isDelete: boolean } >; }; @@ -1467,9 +1479,10 @@ export type BinaryFileType = "file" | "image"; export type PreparedCommit = { /** - * Updated / new source files that are ready to be committed / saved + * Updated / new source files that are ready to be committed / saved. + * A null value signals that the file at that path should be deleted. */ - patchedSourceFiles: Record; + patchedSourceFiles: Record; /** * Previous source files that were patched */ diff --git a/packages/server/src/ValOpsFS.ts b/packages/server/src/ValOpsFS.ts index 98bd36b28..a6e430156 100644 --- a/packages/server/src/ValOpsFS.ts +++ b/packages/server/src/ValOpsFS.ts @@ -671,14 +671,19 @@ export class ValOpsFS extends ValOps { filePath: string, parentRef: ParentRef, patchId: PatchId, - data: string, + data: string | null, _type: BinaryFileType, - metadata: MetadataOfType, + metadata: MetadataOfType | undefined, ): Promise> { const patchDir = this.getParentPatchIdFromParentRef(parentRef); const patchFilePath = this.getBinaryFilePath(filePath, patchDir); const metadataFilePath = this.getBinaryFileMetadataPath(filePath, patchDir); try { + if (data === null) { + this.host.deleteFile(patchFilePath); + this.host.deleteFile(metadataFilePath); + return { patchId, filePath }; + } const buffer = bufferFromDataUrl(data); if (!buffer) { return { @@ -1007,7 +1012,11 @@ export class ValOpsFS extends ValOps { )) { const absPath = fsPath.join(this.rootDir, ...filePath.split("/")); try { - this.host.writeUf8File(absPath, data); + if (data === null) { + this.host.deleteFile(absPath); + } else { + this.host.writeUf8File(absPath, data); + } updatedFiles.push(absPath); } catch (err) { errors[absPath] = { @@ -1178,6 +1187,12 @@ class FSOpsHost { } } + deleteFile(path: string) { + if (this.fileExists(path)) { + fs.rmSync(path); + } + } + moveDir(from: string, to: string) { fs.renameSync(from, to); } diff --git a/packages/server/src/ValOpsHttp.ts b/packages/server/src/ValOpsHttp.ts index 05ddd07a3..a090e74c1 100644 --- a/packages/server/src/ValOpsHttp.ts +++ b/packages/server/src/ValOpsHttp.ts @@ -850,9 +850,9 @@ export class ValOpsHttp extends ValOps { filePathOrRef: string, parentRef: ParentRef, patchId: PatchId, - data: string, + data: string | null, type: BinaryFileType, - metadata: MetadataOfType, + metadata: MetadataOfType | undefined, ): Promise> { const filePath: string = filePathOrRef; diff --git a/packages/server/src/ValServer.ts b/packages/server/src/ValServer.ts index 660a942ec..2f4e76d6d 100644 --- a/packages/server/src/ValServer.ts +++ b/packages/server/src/ValServer.ts @@ -1590,11 +1590,13 @@ export const ValServer = ( patchIds, excludePatchOps: false, }); + console.log("Got patches for save", patches); const analysis = serverOps.analyzePatches( patches.patches, patches.commits, commit, ); + console.log("Got analysis for save", analysis); const preparedCommit = await serverOps.prepare({ ...analysis, ...patches, diff --git a/packages/server/src/patch/ts/ops.ts b/packages/server/src/patch/ts/ops.ts index ad8afc879..2a8f90e67 100644 --- a/packages/server/src/patch/ts/ops.ts +++ b/packages/server/src/patch/ts/ops.ts @@ -656,6 +656,10 @@ function removeFromNode( result.map((index: number) => removeAt(document, node.elements, index)), ); } else if (ts.isObjectLiteralExpression(node)) { + console.log( + "ABOUT TO REMOVE FROM NODE", + printer.printNode(ts.EmitHint.Unspecified, node, document), + ); return pipe( findObjectPropertyAssignment(node, key), result.flatMap( @@ -665,7 +669,7 @@ function removeFromNode( if (!assignment) { return result.err( new PatchError( - "Cannot replace object element which does not exist", + "Cannot remove object element which does not exist", ), ); } diff --git a/packages/ui/spa/components/Field.tsx b/packages/ui/spa/components/Field.tsx index a25a7118c..e2c16bcb6 100644 --- a/packages/ui/spa/components/Field.tsx +++ b/packages/ui/spa/components/Field.tsx @@ -58,9 +58,9 @@ export function Field({ } }, [sourceAtPath, schemaAtPath]); const source = "data" in sourceAtPath ? sourceAtPath.data : undefined; - const isBoolean = - "data" in schemaAtPath && schemaAtPath.data?.type === "boolean"; - const isNullable = "data" in schemaAtPath && schemaAtPath.data?.opt === true; + const schema = "data" in schemaAtPath ? schemaAtPath.data : undefined; + const isBoolean = schema?.type === "boolean"; + const isNullable = schema?.opt === true; return (
- {!isBoolean && isNullable && ( + {schema && !isBoolean && (isNullable || source === null) && ( { if ( - (schemaAtPath.data.type === "image" || - schemaAtPath.data.type === "file") && + (schema.type === "image" || schema.type === "file") && source === null ) { setShowEmptyFileOrImage(true); @@ -89,12 +88,12 @@ export function Field({ op: "replace", path: patchPath, value: emptyOf({ - ...schemaAtPath.data, + ...schema, opt: false, // empty of nullable is null, so we override }) as JSONValue, }, ], - schemaAtPath.data.type, + schema.type, ); } else { addPatch( @@ -105,7 +104,7 @@ export function Field({ value: null, }, ], - schemaAtPath.data.type, + schema.type, ); } } diff --git a/packages/ui/spa/components/FileGallery/FileGallery.tsx b/packages/ui/spa/components/FileGallery/FileGallery.tsx index e8911d6ac..c412afc8c 100644 --- a/packages/ui/spa/components/FileGallery/FileGallery.tsx +++ b/packages/ui/spa/components/FileGallery/FileGallery.tsx @@ -26,8 +26,9 @@ export function FileGallery({ files, onFileRename, onAltTextChange, + onFileDelete, className, - defaultViewMode = "masonry", + defaultViewMode = "list", showSearch = true, imageMode = false, loading = false, @@ -51,8 +52,10 @@ export function FileGallery({ // Apply search filter if (searchQuery.trim()) { const query = searchQuery.toLowerCase(); - result = result.filter((file) => - file.filename.toLowerCase().includes(query), + result = result.filter( + (file) => + file.filename.toLowerCase().includes(query) || + (file.metadata.alt ?? "").toLowerCase().includes(query), ); } @@ -65,6 +68,11 @@ export function FileGallery({ case "name": comparison = a.filename.localeCompare(b.filename); break; + case "description": + comparison = (a.metadata.alt ?? "").localeCompare( + b.metadata.alt ?? "", + ); + break; case "type": comparison = a.metadata.mimeType.localeCompare(b.metadata.mimeType); break; @@ -151,10 +159,10 @@ export function FileGallery({ setSearchQuery(e.target.value)} - className="pl-9 h-8" + className="pl-8" />
)} @@ -168,13 +176,14 @@ export function FileGallery({ title="Upload file" > {uploading ? ( - + ) : ( - + )} )} - + + */}
@@ -271,6 +280,7 @@ export function FileGallery({ onOpenChange={setIsPropertiesOpen} onFileRename={onFileRename} onAltTextChange={onAltTextChange} + onFileDelete={onFileDelete} imageMode={imageMode} loading={loading} disabled={disabled} diff --git a/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx index f8e7c9a3f..d1f7d3b82 100644 --- a/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx +++ b/packages/ui/spa/components/FileGallery/FileGalleryItem.tsx @@ -22,7 +22,12 @@ export function FileGalleryItem({ ? file.metadata.width / file.metadata.height : 1; - const hasErrors = file.validationErrors && file.validationErrors.length > 0; + const hasErrors = + (file.validationErrors && file.validationErrors.length > 0) || + (file.fieldSpecificErrors && + Object.values(file.fieldSpecificErrors).some( + (errs) => errs && errs.length > 0, + )); const buttonContent = ( -

sN0)&6@Si%iE`c`6p#^#`=~h!e^WAa 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�)zH=={fU5mIkgmTN7vaQ{B%~ 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≶QHbIy3j-Od!zP0@l`1%O)huH`7{5Q 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 Ouh^NIqEi2F{r(rN5r)42 literal 0 HcmV?d00001 diff --git a/packages/ui/spa/components/FileGallery/FileGallery.tsx b/packages/ui/spa/components/FileGallery/FileGallery.tsx new file mode 100644 index 000000000..98124da62 --- /dev/null +++ b/packages/ui/spa/components/FileGallery/FileGallery.tsx @@ -0,0 +1,82 @@ +import * as React from "react"; +import { FolderOpen } from "lucide-react"; +import { cn } from "../designSystem/cn"; +import { FileGalleryItem } from "./FileGalleryItem"; +import { FileProperties } from "./FileProperties"; +import { FilePreviewModal } from "./FilePreviewModal"; +import type { FileGalleryProps, GalleryFile } from "./types"; + +export function FileGallery({ + files, + onFileRename, + className, +}: FileGalleryProps) { + const [selectedIndex, setSelectedIndex] = React.useState(null); + const [previewFile, setPreviewFile] = React.useState( + null, + ); + + const selectedFile = + selectedIndex !== null ? (files[selectedIndex] ?? null) : null; + + const handleItemClick = (index: number) => { + setSelectedIndex(selectedIndex === index ? null : index); + }; + + const handleItemDoubleClick = (file: GalleryFile) => { + setPreviewFile(file); + }; + + if (files.length === 0) { + return ( +