@valbuild/language-server 0.116.0 → 0.117.0

package/dist/valbuild-language-server.cjs.prod.js

@@ -857,6 +857,314 @@ function traverseObjectLiteral(node, sourceFile) {
   return map;
 }
 
+/**
+ * Adjudicating the media metadata placeholders core emits unconditionally.
+ *
+ * `ImageSchema.validate` cannot read bytes, so it never answers "does the
+ * stored width/height/mimeType match the file". It defers instead: any
+ * `s.image()` carrying metadata gets an `image:check-metadata` error whether
+ * or not anything is wrong (`packages/core/src/schema/image.ts`), and
+ * `s.file()` does the same with `file:check-metadata`.
+ *
+ * `val validate` resolves those by running the fix handler and then
+ * `createFixPatch` in report mode, which compares each field against the file
+ * and returns one error per field that disagrees. The Studio cannot do that at
+ * all -- a browser has no filesystem -- so it drops them wholesale
+ * (`partitionValidationErrors` in `@valbuild/shared`).
+ *
+ * An editor is in the CLI's position, not the browser's, and publishing the
+ * placeholders raw put a permanent warning on every image in the project. So
+ * they are adjudicated here, by the same comparison `val validate` makes, and
+ * only a real disagreement is shown.
+ */
+/**
+ * The fixes that carry an unconditional metadata placeholder.
+ *
+ * `*:add-metadata` is deliberately absent: it is emitted only when every
+ * metadata field is missing, which needs no adjudication -- there is nothing
+ * stored to compare, and the error stands on its own.
+ */
+const METADATA_CHECK_FIXES = ["image:check-metadata", "file:check-metadata"];
+
+/** One field of a media value that disagrees with the file behind it. */
+
+/**
+ * The verdict on one placeholder. Empty means the metadata agrees with the
+ * file and nothing should be published.
+ */
+
+/**
+ * Whether this error is the unconditional deferral rather than a real finding.
+ *
+ * This is the whole difficulty of the change. `image:check-metadata` is
+ * attached to FIVE different image errors, and only the last is a placeholder:
+ *
+ *  1. `Invalid mime type format`            -- `accept` set, mimeType has no `/`
+ *  2. `Mime type mismatch`                  -- `accept` set and not satisfied
+ *  3. `Could not determine mime type from file extension`
+ *  4. `Mime type and file extension not matching`
+ *  5. the fall-through deferral
+ *
+ * The first four are real: they are about the mime type disagreeing with the
+ * schema or with the filename, neither of which reading the file can settle.
+ * Adjudicating one of them would find the stored metadata matches the bytes and
+ * drop a genuine error -- so they have to be told apart before any file is read.
+ *
+ * There is no flag on `ValidationError` saying which is which, so the four
+ * conditions are re-derived here from the same inputs core used. They are
+ * transcribed from `ImageSchema.executeValidate`, in its order, and
+ * `mediaMetadataChecks.test.ts` drives real core through all five cases to
+ * check that this agrees with it. If core grows a sixth condition, that test is
+ * what catches it.
+ *
+ * `FileSchema` needs none of this: its four equivalent errors carry no `fixes`
+ * at all, so `file:check-metadata` is unambiguous. The test pins that too.
+ */
+function isDeferredMediaMetadataCheck({
+  error,
+  schema
+}) {
+  const fixes = error.fixes ?? [];
+  if (!fixes.some(fix => METADATA_CHECK_FIXES.includes(fix))) {
+    return false;
+  }
+  if (fixes.includes("file:check-metadata")) {
+    return true;
+  }
+  const value = mediaValueOf(error.value);
+  if (typeof value?.path !== "string") {
+    // Nothing to re-derive the conditions from. Keep the error: claiming an
+    // image is fine on no evidence is the worse failure.
+    return false;
+  }
+  const accept = acceptOf(schema);
+  // Core reads `src.mimeType ?? ""`, and every condition below is guarded on
+  // it being non-empty, so an absent mimeType passes all four.
+  const mimeType = typeof value.mimeType === "string" ? value.mimeType : "";
+  if (accept && mimeType && !mimeType.includes("/")) {
+    return false;
+  }
+  if (accept && mimeType && mimeType.includes("/") && !core.Internal.mimeTypeMatchesAccept(mimeType, accept)) {
+    return false;
+  }
+  const fileMimeType = core.Internal.filenameToMimeType(value.path);
+  if (!fileMimeType) {
+    return false;
+  }
+  if (mimeType && fileMimeType !== mimeType) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * {@link isDeferredMediaMetadataCheck} for an error in a module, resolving the
+ * schema it needs.
+ *
+ * Both the adjudicator and `createValDiagnostics` have to make the same call,
+ * on the same inputs -- one to decide what to adjudicate, the other to decide
+ * what to publish -- so it lives here rather than being written out twice.
+ */
+function isDeferredMediaMetadataCheckAt({
+  sourcePath,
+  error,
+  content
+}) {
+  return isDeferredMediaMetadataCheck({
+    error,
+    schema: resolveSchemaAt$1(sourcePath, content)
+  });
+}
+
+/**
+ * Adjudicate every deferred metadata placeholder in `validation`.
+ *
+ * Async, and therefore separate from `createValDiagnostics`, which stays
+ * synchronous so it can be tested without a project -- the same split
+ * `resolveGalleryChecks` uses. The caller runs this first and passes the
+ * result in.
+ */
+async function resolveMediaMetadataChecks({
+  validation,
+  content,
+  valRoot,
+  remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
+}) {
+  const verdicts = new Map();
+  for (const [sourcePath, errors] of Object.entries(validation)) {
+    for (const error of errors) {
+      if (!isDeferredMediaMetadataCheckAt({
+        sourcePath,
+        error,
+        content
+      })) {
+        continue;
+      }
+      const key = mediaMetadataCheckKey(sourcePath, error);
+      try {
+        verdicts.set(key, await adjudicate({
+          sourcePath,
+          error,
+          content,
+          valRoot,
+          remoteHost
+        }));
+      } catch {
+        // This runs inside `validate`, which publishes NOTHING if it throws --
+        // one bad image would silently clear every Val diagnostic in the file.
+        // Keep the placeholder rather than claiming the metadata is fine.
+        verdicts.set(key, keep(error));
+      }
+    }
+  }
+  return verdicts;
+}
+
+/**
+ * Key for one placeholder. A value can in principle carry more than one, so
+ * the fix names are part of the key -- as they are for the gallery checks.
+ */
+function mediaMetadataCheckKey(sourcePath, error) {
+  return `${sourcePath}|${(error.fixes ?? []).join(",")}`;
+}
+
+/** Keeping the placeholder: what to publish when we learned nothing. */
+function keep(error) {
+  return [{
+    message: error.message,
+    ...(error.fixes ? {
+      fixes: error.fixes
+    } : {}),
+    ...(error.value !== undefined ? {
+      value: error.value
+    } : {})
+  }];
+}
+
+/**
+ * What `createFixPatch` says about one placeholder, in report mode.
+ *
+ * `val validate` runs the fix handler first and then `createFixPatch`, but for
+ * these four fixes the handler is `handleFileMetadata`, whose whole job is the
+ * precondition "the ref resolves and the file is on disk". That precondition is
+ * checked directly here instead, for two reasons:
+ *
+ *  - `createValDiagnostics` already reports a missing file as
+ *    `val/file-not-found`, which is a better diagnostic than a metadata
+ *    mismatch and is produced before this verdict is consulted.
+ *  - `handleFileMetadata` resolves the source path through the module, and that
+ *    throws outright for a `.jsonValues()` entry ("Cannot resolve path into a
+ *    jsonValues entry until its content is loaded") -- so routing through it
+ *    would leave every entry-backed image stuck on the placeholder.
+ *
+ * The comparison itself is still `createFixPatch`, unchanged, which is the
+ * parity that matters: the editor's wording is the CLI's wording because it is
+ * the CLI's code -- including for bytes it cannot measure, where it reports
+ * what `val validate` reports rather than a second opinion of our own.
+ *
+ * `createFixPatch` reads and decodes the image itself, so this is one file read
+ * per media field per validation pass, and nothing here should add another.
+ */
+async function adjudicate({
+  sourcePath,
+  error,
+  content,
+  valRoot,
+  remoteHost
+}) {
+  const ref = mediaValueOf(error.value)?.path;
+  if (typeof ref !== "string") {
+    return keep(error);
+  }
+  // A remote ref is a URL and is not expected on disk. Core does not emit these
+  // fixes for one, but a stale ref should not be reported as a local mismatch.
+  if (core.Internal.remote.splitRemoteRef(ref).status === "success") {
+    return keep(error);
+  }
+  if (!fs__default["default"].existsSync(path__default["default"].join(valRoot, ref))) {
+    // Reported as `val/file-not-found` instead; keeping the placeholder here
+    // means this verdict never has the last word on a file that is not there.
+    return keep(error);
+  }
+  let fixed;
+  try {
+    fixed = await server.createFixPatch({
+      projectRoot: valRoot,
+      remoteHost
+    },
+    // `false`: this is a question, not a fix. Asking for the patch would have
+    // createFixPatch read and rewrite files behind the editor's back.
+    false, sourcePath, error, {}, content.source, content.schema);
+  } catch {
+    return keep(error);
+  }
+  return (fixed?.remainingErrors ?? []).map(remaining => ({
+    message: remaining.message,
+    // `createFixPatch` clears `fixes` on the per-field errors it reports, but
+    // the fix is still available and still the remedy -- it is what the
+    // placeholder was asking for. Carrying the placeholder's own fixes is what
+    // keeps the "update image metadata" quick fix offered, and the diagnostic
+    // a Warning rather than an Error.
+    ...(error.fixes ? {
+      fixes: error.fixes
+    } : {}),
+    ...(error.value !== undefined ? {
+      value: error.value
+    } : {})
+  }));
+}
+
+/**
+ * The `accept` a media schema declares, if any.
+ *
+ * Read from the serialized schema (`SerializedImageSchema.options`) rather
+ * than from a schema instance: this runs against what `Service.get` returns.
+ */
+function acceptOf(schema) {
+  if (typeof schema !== "object" || schema === null || !("options" in schema)) {
+    return undefined;
+  }
+  const {
+    options
+  } = schema;
+  if (typeof options !== "object" || options === null || !("accept" in options)) {
+    return undefined;
+  }
+  const {
+    accept
+  } = options;
+  return typeof accept === "string" ? accept : undefined;
+}
+
+/** A media value, read as a plain record. */
+function mediaValueOf(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return undefined;
+  }
+  return value;
+}
+
+/**
+ * The serialized schema at a source path.
+ *
+ * Only the schema is taken from resolution -- `accept` is not on the value, and
+ * the value itself comes from the error. Same call `missingFileRef` in
+ * `diagnostics.ts` makes, and it can fail the same ways (a schema that failed
+ * to serialize, a path that no longer resolves), so failure is not an error
+ * here, just an absence.
+ */
+function resolveSchemaAt$1(sourcePath, content) {
+  if (!content.source || !content.schema) {
+    return undefined;
+  }
+  try {
+    const [, modulePath] = core.Internal.splitModuleFilePathAndModulePath(sourcePath);
+    return core.Internal.resolvePath(modulePath, content.source, content.schema).schema;
+  } catch {
+    return undefined;
+  }
+}
+
 /** Marks diagnostics as ours, so a client can filter on it. */
 const VAL_DIAGNOSTIC_SOURCE = "val";
 
@@ -948,7 +1256,8 @@ function createValDiagnostics({
   text,
   valRoot,
   snapshot,
-  galleryChecks
+  galleryChecks,
+  mediaMetadataChecks
 }) {
   if (content.errors === false) {
     return [];
@@ -1020,6 +1329,33 @@ function createValDiagnostics({
         continue;
       }
 
+      // An unconditional media metadata placeholder: core reports
+      // `image:check-metadata` on every `s.image()` carrying metadata, whether
+      // or not it disagrees with the file. Show only what the adjudication
+      // actually found, and nothing when it found nothing. Deliberately after
+      // the missing-file branch above, so a deleted file is still reported as
+      // `val/file-not-found` rather than as a metadata mismatch.
+      if (isDeferredMediaMetadataCheckAt({
+        sourcePath,
+        error,
+        content
+      })) {
+        const verdict = mediaMetadataChecks?.get(mediaMetadataCheckKey(sourcePath, error));
+        for (const finding of verdict ?? []) {
+          diagnostics.push(build(rangeOf(sourcePath, modulePathMap), finding.message, {
+            code: "val/validation",
+            sourcePath,
+            ...(finding.fixes ? {
+              fixes: finding.fixes
+            } : {}),
+            ...(finding.value !== undefined ? {
+              value: finding.value
+            } : {})
+          }));
+        }
+        continue;
+      }
+
       // A gallery-backed field whose path the gallery does not track. Core
       // reports it with no fix because the remedy is elsewhere; giving it its
       // own code is what lets the editor offer the two remedies.
@@ -2110,6 +2446,17 @@ async function createValCodeActions({
   remoteHost = process.env.VAL_REMOTE_HOST || core.DEFAULT_VAL_REMOTE_HOST
 }) {
   const actions = [];
+  /**
+   * Fixes already offered, as `<fix target>|<fix>`.
+   *
+   * One problem can be reported as several diagnostics that share a fix: a
+   * stale image reports its width and its height separately, and a gallery
+   * check reports one finding per entry. The fix is the same patch each time --
+   * `createFixPatch` corrects every field, and the gallery branch walks every
+   * entry -- so without this the editor offers the identical "Val: update image
+   * metadata" twice, and recomputes it (re-reading the image) to do so.
+   */
+  const offered = new Set();
   for (const diagnostic of diagnostics) {
     const data = diagnostic.data;
     if (!data?.fixes?.length) {
@@ -2148,6 +2495,10 @@ async function createValCodeActions({
       if (!isLocalFix(fix)) {
         continue;
       }
+      const fixTarget = data.fixSourcePath ?? data.sourcePath;
+      if (offered.has(`${fixTarget}|${fix}`)) {
+        continue;
+      }
       const fixEdit = await computeFixEdit({
         document,
         // A gallery check is reported on the entry but fixed against the record
@@ -2169,6 +2520,7 @@ async function createValCodeActions({
       if (!fixEdit) {
         continue;
       }
+      offered.add(`${fixTarget}|${fix}`);
       actions.push(vscodeLanguageserver.CodeAction.create(FIX_TITLES[fix] ?? `Val: ${fix}`,
       // Not always `document.uri`: a fix inside a `.jsonValues()` entry
       // edits the entry's own `*.val.json`, which is a different file from
@@ -3530,6 +3882,14 @@ function createValLanguageServer(connection) {
           runFixHandler: args => activeProject.runFixHandler(args)
         })
       }) : undefined;
+      // Core also defers "does this image's stored metadata match its file",
+      // reporting it on every `s.image()` that carries any metadata. Same
+      // treatment: adjudicate with the fix machinery before showing anything.
+      const mediaMetadataChecks = result.content.errors !== false && result.content.errors.validation ? await resolveMediaMetadataChecks({
+        validation: result.content.errors.validation,
+        content: result.content,
+        valRoot: activeProject.valRoot
+      }) : undefined;
       const diagnostics = createValDiagnostics({
         moduleFilePath,
         content: result.content,
@@ -3540,6 +3900,9 @@ function createValLanguageServer(connection) {
         } : {}),
         ...(galleryChecks ? {
           galleryChecks
+        } : {}),
+        ...(mediaMetadataChecks ? {
+          mediaMetadataChecks
         } : {})
       });
       const unregistered = findMissingModuleDiagnostic(project.valRoot, moduleFilePath, readOpenDocument);