@valbuild/language-server 0.143.1 → 0.144.1

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

@@ -183,7 +183,7 @@ var packageJson = {
 		"lsp",
 		"language-server"
 	],
-	version: "0.143.1",
+	version: "0.144.1",
 	bin: {
 		"val-language-server": "./bin.js"
 	},
@@ -1728,8 +1728,8 @@ function longestResolvedPrefixRange(modulePath, modulePathMap) {
 /**
  * Gallery checks core emits unconditionally.
  *
- * `RecordSchema.validate` attaches these to every `s.imageset()` / `s.fileset()`
- * / `s.videoset()` module whether or not anything is actually wrong (see
+ * `RecordSchema.validate` attaches these to every `s.imagedir()` / `s.filedir()`
+ * / `s.videodir()` module whether or not anything is actually wrong (see
  * `packages/core/src/schema/record.ts`): they are placeholders asking someone to
  * go and look. `val validate` looks by running the matching fix handler, which
  * reports success when the directory is unique and every file is accounted for.
@@ -1839,7 +1839,7 @@ function dropDeferredPlaceholders(validation) {
  *
  * `ImageSchema.validate` reports this (`packages/core/src/schema/image.ts`:
  * "The gallery does not have an image at '…'"), and `VideoSchema.validate` the
- * same for a field picked from an `s.videoset()` ("The set does not have a
+ * same for a field picked from an `s.videodir()` ("The set does not have a
  * video at '…'"), but neither attaches a `ValidationFix`,
  * because the remedy is not a change to this module: either the gallery gains an
  * entry, or the file moves into the gallery's directory. Both are edits to
@@ -2027,6 +2027,144 @@ function toModuleFilePath(valRoot, uri) {
   return `/${relative.split(path__default["default"].sep).join("/")}`;
 }
 
+const jsonOps = new patch.JSONOps();
+
+/**
+ * Turning a fix patch into an edit when the value it fixes is NOT in the
+ * `.val.ts` the diagnostic was reported on.
+ *
+ * A `.jsonValues()` record keeps each entry's value in its own `*.val.json`; the
+ * `.val.ts` holds `c.json(() => import("./x.val.json"))` and nothing below it.
+ * So a fix for, say, an `s.image()` inside an entry produces a patch whose path
+ * starts at the module root (`["/jobb/student", "pageImage", "width"]`) but
+ * whose target lives in another file entirely.
+ *
+ * Applying such a patch to the `.val.ts` cannot work: the walk reaches the
+ * `c.json(...)` call expression and `TSOps` refuses it ("Expression must be a
+ * literal"). That refusal is why an editor silently offered no quick fix at all
+ * for anything inside an entry — `computeFixEdit` saw an error result and
+ * dropped the action.
+ *
+ * The routing here is the same one the Studio's publish and `val validate --fix`
+ * use — {@link classifyJsonValuesOp} to find the entry, {@link rebaseContentOp}
+ * to drop the entry-key prefix — so all three write the same file the same way.
+ * What is specific to the editor is only the last step: the result comes back as
+ * a `TextEdit` against the entry's document rather than as a write to disk, so
+ * the edit goes through the editor's undo stack and respects an unsaved buffer.
+ */
+
+function jsonEntryEditFor({
+  patch: patch$1,
+  schema,
+  moduleFilePath,
+  valTsText,
+  valRoot,
+  read
+}) {
+  if (!schema) {
+    return undefined;
+  }
+  const entry = entryOpsOf(patch$1, schema);
+  if (!entry) {
+    return undefined;
+  }
+  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, ts__default["default"].createSourceFile(moduleFilePath, valTsText, ts__default["default"].ScriptTarget.ES2020), entry.entryKey);
+  if (!jsonFilePath) {
+    return undefined;
+  }
+  const absolutePath = path__default["default"].join(valRoot, jsonFilePath);
+  const before = read?.(absolutePath) ?? readFile(absolutePath);
+  if (before === undefined) {
+    return undefined;
+  }
+  let content;
+  try {
+    content = JSON.parse(before);
+  } catch {
+    // A malformed entry file is already reported as a load error; offering an
+    // edit computed from a guess at its contents would be worse than offering
+    // nothing.
+    return undefined;
+  }
+  for (const op of entry.ops) {
+    // Root-only, like the rest of the `.jsonValues()` machinery, so the prefix
+    // to drop is exactly the entry key.
+    const rebased = server.rebaseContentOp(op, 1);
+    if (fp.result.isErr(rebased)) {
+      return undefined;
+    }
+    const applied = patch.applyPatch(patch.deepClone(content), jsonOps, [rebased.value]);
+    if (fp.result.isErr(applied)) {
+      return undefined;
+    }
+    content = applied.value;
+  }
+  // Re-serialising the whole value and diffing it is what keeps this honest:
+  // the alternative is editing JSON text by hand, and the fix would then differ
+  // from what the CLI writes. `minimalTextEdit` narrows the result to the region
+  // that actually changed, so a two-space-indented file (what prettier and the
+  // CLI both produce) yields an edit covering the changed properties and no
+  // more. A file indented differently gets a correct but larger edit.
+  const after = JSON.stringify(content, null, 2) + (before.endsWith("\n") ? "\n" : "");
+  const uri = pathToUri(absolutePath);
+  const edit = minimalTextEdit(before, after, vscodeLanguageserverTextdocument.TextDocument.create(uri, "json", 0, before));
+  return edit && {
+    uri,
+    edit
+  };
+}
+
+/**
+ * The ops of `patch`, if every one of them edits the content of ONE
+ * `.jsonValues()` entry. `undefined` for anything else — an ordinary module, a
+ * patch that also touches the `.val.ts`, or one that adds or removes a whole
+ * entry — because those either belong on the `.val.ts` (the caller's existing
+ * path) or need both files written at once, which a single `TextEdit` cannot do.
+ */
+function entryOpsOf(patch, schema) {
+  let entryKey;
+  const ops = [];
+  for (const op of patch) {
+    const cls = server.classifyJsonValuesOp(schema, op.path);
+    if (cls.kind !== "entry") {
+      return undefined;
+    }
+    // Nested `.jsonValues()` is rejected as a module error long before a fix is
+    // offered; treat it as out of scope rather than writing to a guessed file.
+    if (cls.recordPath.length > 0 || cls.subPath.length === 0) {
+      return undefined;
+    }
+    // `move` and `copy` carry a second path, and `rebaseContentOp` slices `from`
+    // by the same prefix as `path` -- so an op reaching outside this entry would
+    // have its source silently reinterpreted as a path inside this entry's file.
+    if (op.op === "move" || op.op === "copy") {
+      const fromCls = server.classifyJsonValuesOp(schema, op.from);
+      if (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey) {
+        return undefined;
+      }
+    }
+    if (entryKey !== undefined && entryKey !== cls.entryKey) {
+      return undefined;
+    }
+    entryKey = cls.entryKey;
+    ops.push(op);
+  }
+  if (entryKey === undefined || ops.length === 0) {
+    return undefined;
+  }
+  return {
+    entryKey,
+    ops
+  };
+}
+function readFile(filePath) {
+  try {
+    return fs__default["default"].readFileSync(filePath, "utf8");
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * `workspace/executeCommand` handlers.
  *
@@ -2301,9 +2439,11 @@ function createValCommands(deps) {
     // them in the same edit, so one undo takes back all of it.
     const unwritten = [];
     for (const other of outcome.otherModulePatches ?? []) {
-      const otherEdit = editForModulePatch(project.valRoot, other);
-      if (otherEdit) {
-        (changes[otherEdit.uri] ??= []).push(otherEdit.edit);
+      const otherEdits = await editsForModulePatch(project, other);
+      if (otherEdits) {
+        for (const otherEdit of otherEdits) {
+          (changes[otherEdit.uri] ??= []).push(otherEdit.edit);
+        }
       } else {
         unwritten.push(other.moduleFilePath);
       }
@@ -2330,31 +2470,84 @@ function createValCommands(deps) {
   }
 
   /**
-   * The edit for a patch to another module than the one the command ran on,
-   * against the editor's buffer when the file is open and the disk otherwise.
+   * The edits for a patch to another module than the one the command ran on,
+   * against the editor's buffers when the files are open and the disk
+   * otherwise. `undefined` when any part of it cannot be written: half a rename
+   * is worse than a warning naming the module.
+   *
+   * A `.jsonValues()` entry's value is in its own `*.val.json`, not in the
+   * `.val.ts` — so the ops are split by the entry they land in, and each
+   * entry's go through `jsonEntryEditFor`, the same routing a quick fix inside
+   * an entry uses. Only what is left is applied to the `.val.ts`.
    */
-  function editForModulePatch(valRoot, other) {
-    const uri = pathToUri(path__default["default"].join(valRoot, other.moduleFilePath));
-    let otherDocument = deps.getDocument(uri);
-    if (!otherDocument) {
-      let text;
-      try {
-        text = fs__default["default"].readFileSync(path__default["default"].join(valRoot, other.moduleFilePath), "utf8");
-      } catch {
+  async function editsForModulePatch(project, other) {
+    const {
+      valRoot
+    } = project;
+    const moduleFile = path__default["default"].join(valRoot, other.moduleFilePath);
+    const uri = pathToUri(moduleFile);
+    const valTsText = readBuffer(moduleFile);
+    if (valTsText === undefined) {
+      return undefined;
+    }
+    const moduleResult = await project.getModule(other.moduleFilePath, {
+      validate: false
+    });
+    const schema = moduleResult.status === "ok" ? moduleResult.content.schema : undefined;
+    const valTsOps = [];
+    const entryOps = new Map();
+    for (const op of other.patch) {
+      const cls = schema && server.classifyJsonValuesOp(schema, op.path);
+      if (cls && cls.kind === "entry") {
+        const ops = entryOps.get(cls.entryKey) ?? [];
+        ops.push(op);
+        entryOps.set(cls.entryKey, ops);
+      } else {
+        valTsOps.push(op);
+      }
+    }
+    const edits = [];
+    for (const ops of entryOps.values()) {
+      const entryEdit = jsonEntryEditFor({
+        patch: ops,
+        schema,
+        moduleFilePath: other.moduleFilePath,
+        valTsText,
+        valRoot,
+        read: readBuffer
+      });
+      if (!entryEdit) {
         return undefined;
       }
-      otherDocument = vscodeLanguageserverTextdocument.TextDocument.create(uri, "typescript", 0, text);
+      edits.push(entryEdit);
+    }
+    if (valTsOps.length > 0) {
+      const patched = server.patchSourceFile(valTsText, valTsOps);
+      if (fp.result.isErr(patched)) {
+        return undefined;
+      }
+      const edit = minimalTextEdit(valTsText, patched.value.text, vscodeLanguageserverTextdocument.TextDocument.create(uri, "typescript", 0, valTsText));
+      if (edit) {
+        edits.push({
+          uri,
+          edit
+        });
+      }
+    }
+    return edits;
+  }
+
+  /** A file as the editor has it, falling back to disk. */
+  function readBuffer(fsPath) {
+    const open = deps.getDocument(pathToUri(fsPath));
+    if (open) {
+      return open.getText();
     }
-    const otherBefore = otherDocument.getText();
-    const otherPatched = server.patchSourceFile(otherBefore, other.patch);
-    if (fp.result.isErr(otherPatched)) {
+    try {
+      return fs__default["default"].readFileSync(fsPath, "utf8");
+    } catch {
       return undefined;
     }
-    const otherEdit = minimalTextEdit(otherBefore, otherPatched.value.text, otherDocument);
-    return otherEdit && {
-      uri,
-      edit: otherEdit
-    };
   }
   return {
     async execute(command, args) {
@@ -2537,144 +2730,6 @@ function valModulesEntryText({
   return hasElements ? `,\n${indentation}${entry}` : `\n${indentation}${entry}\n${indentation.slice(2)}`;
 }
 
-const jsonOps = new patch.JSONOps();
-
-/**
- * Turning a fix patch into an edit when the value it fixes is NOT in the
- * `.val.ts` the diagnostic was reported on.
- *
- * A `.jsonValues()` record keeps each entry's value in its own `*.val.json`; the
- * `.val.ts` holds `c.json(() => import("./x.val.json"))` and nothing below it.
- * So a fix for, say, an `s.image()` inside an entry produces a patch whose path
- * starts at the module root (`["/jobb/student", "pageImage", "width"]`) but
- * whose target lives in another file entirely.
- *
- * Applying such a patch to the `.val.ts` cannot work: the walk reaches the
- * `c.json(...)` call expression and `TSOps` refuses it ("Expression must be a
- * literal"). That refusal is why an editor silently offered no quick fix at all
- * for anything inside an entry — `computeFixEdit` saw an error result and
- * dropped the action.
- *
- * The routing here is the same one the Studio's publish and `val validate --fix`
- * use — {@link classifyJsonValuesOp} to find the entry, {@link rebaseContentOp}
- * to drop the entry-key prefix — so all three write the same file the same way.
- * What is specific to the editor is only the last step: the result comes back as
- * a `TextEdit` against the entry's document rather than as a write to disk, so
- * the edit goes through the editor's undo stack and respects an unsaved buffer.
- */
-
-function jsonEntryEditFor({
-  patch: patch$1,
-  schema,
-  moduleFilePath,
-  valTsText,
-  valRoot,
-  read
-}) {
-  if (!schema) {
-    return undefined;
-  }
-  const entry = entryOpsOf(patch$1, schema);
-  if (!entry) {
-    return undefined;
-  }
-  const jsonFilePath = server.findJsonEntryFilePath(moduleFilePath, ts__default["default"].createSourceFile(moduleFilePath, valTsText, ts__default["default"].ScriptTarget.ES2020), entry.entryKey);
-  if (!jsonFilePath) {
-    return undefined;
-  }
-  const absolutePath = path__default["default"].join(valRoot, jsonFilePath);
-  const before = read?.(absolutePath) ?? readFile(absolutePath);
-  if (before === undefined) {
-    return undefined;
-  }
-  let content;
-  try {
-    content = JSON.parse(before);
-  } catch {
-    // A malformed entry file is already reported as a load error; offering an
-    // edit computed from a guess at its contents would be worse than offering
-    // nothing.
-    return undefined;
-  }
-  for (const op of entry.ops) {
-    // Root-only, like the rest of the `.jsonValues()` machinery, so the prefix
-    // to drop is exactly the entry key.
-    const rebased = server.rebaseContentOp(op, 1);
-    if (fp.result.isErr(rebased)) {
-      return undefined;
-    }
-    const applied = patch.applyPatch(patch.deepClone(content), jsonOps, [rebased.value]);
-    if (fp.result.isErr(applied)) {
-      return undefined;
-    }
-    content = applied.value;
-  }
-  // Re-serialising the whole value and diffing it is what keeps this honest:
-  // the alternative is editing JSON text by hand, and the fix would then differ
-  // from what the CLI writes. `minimalTextEdit` narrows the result to the region
-  // that actually changed, so a two-space-indented file (what prettier and the
-  // CLI both produce) yields an edit covering the changed properties and no
-  // more. A file indented differently gets a correct but larger edit.
-  const after = JSON.stringify(content, null, 2) + (before.endsWith("\n") ? "\n" : "");
-  const uri = pathToUri(absolutePath);
-  const edit = minimalTextEdit(before, after, vscodeLanguageserverTextdocument.TextDocument.create(uri, "json", 0, before));
-  return edit && {
-    uri,
-    edit
-  };
-}
-
-/**
- * The ops of `patch`, if every one of them edits the content of ONE
- * `.jsonValues()` entry. `undefined` for anything else — an ordinary module, a
- * patch that also touches the `.val.ts`, or one that adds or removes a whole
- * entry — because those either belong on the `.val.ts` (the caller's existing
- * path) or need both files written at once, which a single `TextEdit` cannot do.
- */
-function entryOpsOf(patch, schema) {
-  let entryKey;
-  const ops = [];
-  for (const op of patch) {
-    const cls = server.classifyJsonValuesOp(schema, op.path);
-    if (cls.kind !== "entry") {
-      return undefined;
-    }
-    // Nested `.jsonValues()` is rejected as a module error long before a fix is
-    // offered; treat it as out of scope rather than writing to a guessed file.
-    if (cls.recordPath.length > 0 || cls.subPath.length === 0) {
-      return undefined;
-    }
-    // `move` and `copy` carry a second path, and `rebaseContentOp` slices `from`
-    // by the same prefix as `path` -- so an op reaching outside this entry would
-    // have its source silently reinterpreted as a path inside this entry's file.
-    if (op.op === "move" || op.op === "copy") {
-      const fromCls = server.classifyJsonValuesOp(schema, op.from);
-      if (fromCls.kind !== "entry" || fromCls.entryKey !== cls.entryKey) {
-        return undefined;
-      }
-    }
-    if (entryKey !== undefined && entryKey !== cls.entryKey) {
-      return undefined;
-    }
-    entryKey = cls.entryKey;
-    ops.push(op);
-  }
-  if (entryKey === undefined || ops.length === 0) {
-    return undefined;
-  }
-  return {
-    entryKey,
-    ops
-  };
-}
-function readFile(filePath) {
-  try {
-    return fs__default["default"].readFileSync(filePath, "utf8");
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * What the client announced it will do with a `WorkspaceEdit`.
  *