@valbuild/core 0.101.0 → 0.102.0

package/dist/{index-3e2d700e.cjs.dev.js → index-30ecb49c.cjs.dev.js}

@@ -922,6 +922,7 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
       var _this$options4, _this$options5, _this$options6, _this$customValidateF, _this$customValidateF2;
       return {
         type: "string",
+        render: this.renderInput ? true : undefined,
         options: {
           maxLength: (_this$options4 = this.options) === null || _this$options4 === void 0 ? void 0 : _this$options4.maxLength,
           minLength: (_this$options5 = this.options) === null || _this$options5 === void 0 ? void 0 : _this$options5.minLength,
@@ -947,7 +948,12 @@ var StringSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "executeRender",
-    value: function executeRender(sourcePath, src) {
+    value: function executeRender(sourcePath, src,
+    // Accepted and unused: a string's render is a static layout hint
+    // (`{as:"textarea"}` / `{as:"code",language}`) with no closure behind it, so
+    // there is nothing a scope could prune. Declared so the signature is uniform
+    // across every schema rather than something a reader has to check.
+    _scope) {
       if (this.renderInput) {
         if (this.renderInput.as === "code") {
           return _defineProperty({}, sourcePath, {
@@ -1160,7 +1166,7 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "executeRender",
-    value: function executeRender(sourcePath, src) {
+    value: function executeRender(sourcePath, src, scope) {
       var res = {};
       if (src === null) {
         return res;
@@ -1171,7 +1177,13 @@ var ObjectSchema = /*#__PURE__*/function (_Schema) {
           continue;
         }
         var subPath = unsafeCreateSourcePath(sourcePath, _key3);
-        var itemResult = this.items[_key3]["executeRender"](subPath, itemSrc);
+        // An object produces no render of its own, so it is pure recursion — and
+        // pruning it is the whole contribution: a field deep in one branch stops
+        // paying for every sibling branch's renders.
+        if (scope !== undefined && !scope.wantsUnder(subPath)) {
+          continue;
+        }
+        var itemResult = this.items[_key3]["executeRender"](subPath, itemSrc, scope);
         for (var keyS in itemResult) {
           var _key4 = keyS;
           res[_key4] = itemResult[_key4];
@@ -1313,6 +1325,7 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
         type: "array",
         item: this.item["executeSerialize"](),
         opt: this.opt,
+        render: this.renderInput ? true : undefined,
         customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
         readonly: this.isReadonly,
         hidden: this.isHidden,
@@ -1321,7 +1334,7 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "executeRender",
-    value: function executeRender(sourcePath, src) {
+    value: function executeRender(sourcePath, src, scope) {
       var res = {};
       if (src === null) {
         return res;
@@ -1333,7 +1346,10 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
           continue;
         }
         var subPath = unsafeCreateSourcePath(sourcePath, key);
-        var itemResult = this.item["executeRender"](subPath, itemSrc);
+        if (scope !== undefined && !scope.wantsUnder(subPath)) {
+          continue;
+        }
+        var itemResult = this.item["executeRender"](subPath, itemSrc, scope);
         for (var keyS in itemResult) {
           var _key = keyS;
           res[_key] = itemResult[_key];
@@ -1349,34 +1365,51 @@ var ArraySchema = /*#__PURE__*/function (_Schema) {
             message: "Unknown layout type: " + layout
           };
         }
-        try {
-          res[sourcePath] = {
-            status: "success",
-            data: {
-              layout: "list",
-              parent: "array",
-              items: src.map(function (val) {
-                // NB NB: display is actually defined by the user
-                var _select = select({
-                    val: val
-                  }),
-                  title = _select.title,
-                  subtitle = _select.subtitle,
-                  image = _select.image;
-                return {
-                  title: title,
-                  subtitle: subtitle,
-                  image: image
-                };
-              })
-            }
-          };
-        } catch (e) {
-          res[sourcePath] = {
-            status: "error",
-            message: e instanceof Error ? e.message : "Unknown error"
-          };
+        // The whole list when the LIST is what is being shown; only the wanted
+        // rows when it is not. `select` is the user's closure and the real expense
+        // — a list view asks for the container and gets every row, a single field
+        // asks for its own path and costs one call.
+        // Non-null once, as a value, rather than a boolean the compiler cannot
+        // tie back to `scope`: no scope and a scope that wants this exact path
+        // both mean the whole list, and anything else is a window.
+        var window = scope !== undefined && !scope.wants(sourcePath) ? scope : null;
+        var items = [];
+        for (var index = 0; index < src.length; index++) {
+          if (window !== null && !window.wantsUnder(unsafeCreateSourcePath(sourcePath, index))) {
+            continue;
+          }
+          // Per ITEM, not per list, matching what `record` already does: `select`
+          // is user code, and one row whose data trips it up must not take out the
+          // whole list. Before scoping, one throwing row produced an error at the
+          // container and no items at all.
+          try {
+            // NB NB: display is actually defined by the user
+            var _select = select({
+                val: src[index]
+              }),
+              title = _select.title,
+              subtitle = _select.subtitle,
+              image = _select.image;
+            items.push([index, {
+              title: title,
+              subtitle: subtitle,
+              image: image
+            }]);
+          } catch (e) {
+            res[unsafeCreateSourcePath(sourcePath, index)] = {
+              status: "error",
+              message: e instanceof Error ? e.message : "Unknown error"
+            };
+          }
         }
+        res[sourcePath] = {
+          status: "success",
+          data: {
+            layout: "list",
+            parent: "array",
+            items: items
+          }
+        };
       }
       return res;
     }
@@ -1950,7 +1983,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "executeRender",
-    value: function executeRender(sourcePath, src) {
+    value: function executeRender(sourcePath, src, scope) {
       var res = {};
       if (src === null) {
         return res;
@@ -1972,7 +2005,7 @@ var UnionSchema = /*#__PURE__*/function (_Schema) {
           return false;
         });
         if (thisSchema) {
-          var itemResult = thisSchema["executeRender"](sourcePath, src);
+          var itemResult = thisSchema["executeRender"](sourcePath, src, scope);
           for (var keyS in itemResult) {
             var _key3 = keyS;
             res[_key3] = itemResult[_key3];
@@ -3859,6 +3892,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
         item: this.item["executeSerialize"](),
         key: (_this$keySchema = this.keySchema) === null || _this$keySchema === void 0 ? void 0 : _this$keySchema["executeSerialize"](),
         opt: this.opt,
+        render: this.renderInput ? true : undefined,
         router: (_this$currentRouter = this.currentRouter) === null || _this$currentRouter === void 0 ? void 0 : _this$currentRouter.getRouterId(),
         customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
         jsonValues: this.isJsonValues ? true : undefined,
@@ -3891,7 +3925,7 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
     }
   }, {
     key: "executeRender",
-    value: function executeRender(sourcePath, src) {
+    value: function executeRender(sourcePath, src, scope) {
       var res = {};
       if (src === null) {
         return res;
@@ -3909,7 +3943,10 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           continue;
         }
         var subPath = unsafeCreateSourcePath(sourcePath, _key);
-        var itemResult = this.item["executeRender"](subPath, itemSrc);
+        if (scope !== undefined && !scope.wantsUnder(subPath)) {
+          continue;
+        }
+        var itemResult = this.item["executeRender"](subPath, itemSrc, scope);
         for (var keyS in itemResult) {
           var _key2 = keyS;
           res[_key2] = itemResult[_key2];
@@ -3925,6 +3962,9 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
             message: "Unknown layout type: " + layout
           };
         }
+        // See the same block in `array`: the whole record when the record is what
+        // is being shown, only the wanted entries when it is not.
+        var window = scope !== undefined && !scope.wants(sourcePath) ? scope : null;
         var items = [];
         for (var _i = 0, _Object$entries = Object.entries(src); _i < _Object$entries.length; _i++) {
           var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
@@ -3933,6 +3973,9 @@ var RecordSchema = /*#__PURE__*/function (_Schema) {
           if (isJson(val)) {
             continue; // as above: nothing to select from an un-loaded entry
           }
+          if (window !== null && !window.wantsUnder(unsafeCreateSourcePath(sourcePath, _key3))) {
+            continue;
+          }
           // Per KEY, not per record: `select` is user code, and one entry whose
           // data trips it up must not take out the whole list.
           try {
@@ -5065,8 +5108,8 @@ var keyOf = function keyOf(valModule) {
  * ```
  */
 var files = function files(options) {
-  var _options$directory, _options$remote;
-  var directory = (_options$directory = options.directory) !== null && _options$directory !== void 0 ? _options$directory : "/public/val";
+  var _options$remote;
+  var directory = options.directory;
   var itemSchema = new ObjectSchema({
     mimeType: new StringSchema({}, false)
   }, false);
@@ -6119,8 +6162,9 @@ function router(router, keyOrItem, maybeItem) {
 /**
  * Define a collection of images.
  *
- * All options are optional: `s.images()` accepts any image type (`"image/*"`) in
- * the default `/public/val` directory, with nullable alt text and remote disabled.
+ * `directory` is required — it decides where uploads land, so it is not something
+ * to be inferred. The rest defaults: any image type (`"image/*"`), nullable alt
+ * text, remote disabled.
  *
  * @example
  * ```typescript
@@ -6140,9 +6184,9 @@ function router(router, keyOrItem, maybeItem) {
  * ```
  */
 var images = function images(options) {
-  var _options$directory, _options$alt, _options$accept, _options$remote;
-  var directory = (_options$directory = options === null || options === void 0 ? void 0 : options.directory) !== null && _options$directory !== void 0 ? _options$directory : "/public/val";
-  var altSchema = (_options$alt = options === null || options === void 0 ? void 0 : options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
+  var _options$alt, _options$accept, _options$remote;
+  var directory = options.directory;
+  var altSchema = (_options$alt = options.alt) !== null && _options$alt !== void 0 ? _options$alt : string().nullable();
   var itemSchema = new ObjectSchema({
     width: new NumberSchema(undefined, false),
     height: new NumberSchema(undefined, false),
@@ -6151,9 +6195,9 @@ var images = function images(options) {
   }, false);
   return new RecordSchema(itemSchema, false, [], null, null, {
     type: "images",
-    accept: (_options$accept = options === null || options === void 0 ? void 0 : options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
+    accept: (_options$accept = options.accept) !== null && _options$accept !== void 0 ? _options$accept : "image/*",
     directory: directory,
-    remote: (_options$remote = options === null || options === void 0 ? void 0 : options.remote) !== null && _options$remote !== void 0 ? _options$remote : false,
+    remote: (_options$remote = options.remote) !== null && _options$remote !== void 0 ? _options$remote : false,
     altSchema: altSchema
   });
 };
@@ -6754,7 +6798,7 @@ function collectObjectRecursive(item, collector) {
  * Extracts schemas and sources from a ValModules registry and computes the
  * deterministic SHAs that the server and client both use to detect changes.
  *
- * Used by ValOps on the server and by ValSyncEngine on the client so the
+ * Used by ValOps on the server and by `HostStore` on the client so the
  * hash algorithm has a single source of truth.
  */
 function extractValModules(_x) {
@@ -6930,6 +6974,104 @@ function _extractValModules() {
   return _extractValModules.apply(this, arguments);
 }
 
+/**
+ * Does this schema store any file remotely?
+ *
+ * The one answer to that question. There used to be two — `hasRemoteFileSchema`
+ * in the server, gating whether `/save` demands remote credentials, and
+ * `findRequiredRemoteFiles` in the Studio, gating the `/remote/settings` fetch —
+ * and they disagreed about `s.images({ remote: true })`: the Studio's counted a
+ * remote media record, the server's did not, because a media collection
+ * serializes as a `record` of metadata rather than as an image schema.
+ *
+ * The server's answer was the wrong one, and silently so. With it false,
+ * `/save` runs `saveOrUploadFiles` in `skip-remote` mode, and that mode does not
+ * merely skip the upload — it drops every remote descriptor without an error. The
+ * commit then lands a remote ref with no bytes behind it: a broken image, in the
+ * repository, with nothing anywhere saying why.
+ *
+ * ## Why it stays a walk over the SERIALIZED schema
+ *
+ * Both callers have a `SerializedSchema` and not a `Schema`: the server reads
+ * them out of `getSchemas()`, and the Studio is handed them by `host.receive`.
+ * Asking the schema classes directly would mean a method on every one of them,
+ * and the two places that need the answer cannot call it.
+ *
+ * ## Throwing
+ *
+ * The `never` assignment at the end is the point of the default branch: adding a
+ * schema type without teaching this function about it must not compile. The throw
+ * is what happens if one arrives anyway — which for a caller reading schemas out
+ * of its own process should be impossible. A caller that cannot afford to throw
+ * (the Studio, whose whole UI is downstream of this) catches it; returning `false`
+ * instead would reintroduce exactly the silent skip described above.
+ */
+function hasRemoteFileSchema(schema) {
+  if (schema.type === "file" || schema.type === "image") {
+    return !!schema.remote;
+  } else if (schema.type === "richtext") {
+    var _schema$options;
+    if (_typeof((_schema$options = schema.options) === null || _schema$options === void 0 || (_schema$options = _schema$options.inline) === null || _schema$options === void 0 ? void 0 : _schema$options.img) === "object") {
+      return hasRemoteFileSchema(schema.options.inline.img);
+    }
+    return false;
+  } else if (schema.type === "array") {
+    return hasRemoteFileSchema(schema.item);
+  } else if (schema.type === "record") {
+    /**
+     * A media collection — `s.images()` / `s.files()` — is the case both of the
+     * old functions were written around, and the one they disagreed on.
+     *
+     * It has no file or image schema inside it to find: `item` is an object of
+     * width/height/mimeType/alt, and the file itself is named by the record's
+     * KEY. So `remote` on the record is the only place the answer is written
+     * down, and recursing into `item` can only ever say no.
+     */
+    if (schema.mediaType && schema.remote) {
+      return true;
+    }
+    return hasRemoteFileSchema(schema.item);
+  } else if (schema.type === "object") {
+    for (var key in schema.items) {
+      var hasRemoteFile = hasRemoteFileSchema(schema.items[key]);
+      if (hasRemoteFile) {
+        return true;
+      }
+    }
+    return false;
+  } else if (schema.type === "union") {
+    var unionStringSchema = _typeof(schema.key) === "object" && schema.key.type === "literal" ? schema : undefined;
+    var unionObjectSchema = typeof schema.key === "string" ? schema : undefined;
+    if (unionStringSchema) {
+      // A string union's items are literals, so there is nothing to look inside.
+      return false;
+    }
+    if (unionObjectSchema) {
+      var _iterator = result._createForOfIteratorHelper(unionObjectSchema.items),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var item = _step.value;
+          var _hasRemoteFile = hasRemoteFileSchema(item);
+          if (_hasRemoteFile) {
+            return true;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+    return false;
+  } else if (schema.type === "boolean" || schema.type === "number" || schema.type === "string" || schema.type === "literal" || schema.type === "date" || schema.type === "dateTime" || schema.type === "color" || schema.type === "keyOf" || schema.type === "route") {
+    return false;
+  } else {
+    var exhaustiveCheck = schema;
+    throw new Error("Unexpected schema: ".concat(JSON.stringify(exhaustiveCheck)));
+  }
+}
+
 var DEFAULT_VAL_REMOTE_HOST = "https://remote.val.build";
 function convertRemoteSource(src) {
   if (src !== null && src !== void 0 && src.patch_id) {
@@ -7922,6 +8064,94 @@ function deserializeSchemaImpl(serialized) {
   }
 }
 
+// TODO: we want to change layout -> as to be more consistent across the board
+
+// Main render type:
+
+//
+
+/**
+ * Which paths a render is being computed FOR.
+ *
+ * `executeRender` takes a whole module, so one request has always walked every
+ * node in it and run every `select` closure — for `handboka`, with `select` at
+ * two nested array levels, that is every chapter and every section to serve one
+ * visible row. A scope is what makes the walk proportional to what is being
+ * looked at instead of to the project.
+ *
+ * Two questions, because a container and its items need different answers:
+ *
+ * - {@link RenderScope.wants} — is a render AT this exact path wanted? A
+ *   container answers `true` here when the whole of it is being shown, and its
+ *   list render is then computed in full.
+ * - {@link RenderScope.wantsUnder} — could anything at or below this path be
+ *   wanted? Recursion is pruned where this is `false`, and a container whose own
+ *   path is not wanted but which has wanted descendants renders a WINDOW: only
+ *   the items that were asked for. That is the case a single visible row is, and
+ *   it is why {@link ListArrayRender} carries indices.
+ *
+ * Absent scope means the whole module, which is what every existing caller
+ * passes and what every existing caller got.
+ */
+
+/**
+ * A scope covering exactly `paths` and their subtrees.
+ *
+ * Compares SEGMENTS rather than string prefixes. A source path's module path is
+ * a quoted, dot-joined encoding (`?p="a".1."b"`), so `startsWith` gets the
+ * ancestor test wrong wherever a key is a prefix of a sibling key or contains a
+ * dot or a quote — `"title"` against `"titles"` being the cheapest example.
+ * Segments are parsed once here, not per comparison.
+ */
+function renderScope(paths) {
+  var wanted = paths.map(function (path) {
+    var _splitModuleFilePathA = splitModuleFilePathAndModulePath(path),
+      _splitModuleFilePathA2 = _slicedToArray(_splitModuleFilePathA, 2),
+      moduleFilePath = _splitModuleFilePathA2[0],
+      modulePath = _splitModuleFilePathA2[1];
+    return {
+      moduleFilePath: moduleFilePath,
+      segments: modulePath === "" ? [] : splitModulePath(modulePath)
+    };
+  });
+  var parse = function parse(path) {
+    var _splitModuleFilePathA3 = splitModuleFilePathAndModulePath(path),
+      _splitModuleFilePathA4 = _slicedToArray(_splitModuleFilePathA3, 2),
+      moduleFilePath = _splitModuleFilePathA4[0],
+      modulePath = _splitModuleFilePathA4[1];
+    return {
+      moduleFilePath: moduleFilePath,
+      segments: modulePath === "" ? [] : splitModulePath(modulePath)
+    };
+  };
+  var isPrefix = function isPrefix(prefix, of) {
+    if (prefix.length > of.length) return false;
+    for (var i = 0; i < prefix.length; i++) {
+      if (prefix[i] !== of[i]) return false;
+    }
+    return true;
+  };
+  return {
+    wants: function wants(path) {
+      var at = parse(path);
+      return wanted.some(function (entry) {
+        return entry.moduleFilePath === at.moduleFilePath && entry.segments.length === at.segments.length && isPrefix(entry.segments, at.segments);
+      });
+    },
+    wantsUnder: function wantsUnder(path) {
+      var at = parse(path);
+      return wanted.some(function (entry) {
+        return entry.moduleFilePath === at.moduleFilePath && (
+        // Either direction: a wanted path below `path` means recurse into it,
+        // and a wanted path ABOVE it means the whole subtree was asked for.
+        isPrefix(at.segments, entry.segments) || isPrefix(entry.segments, at.segments));
+      });
+    }
+  };
+}
+
+// TODO: improve this so that we do not get RawString and string, only string. Are there other things?
+
 var externalPageRouter = {
   getRouterId: function getRouterId() {
     return "external-url-router";
@@ -8321,6 +8551,8 @@ exports.derefPatch = derefPatch;
 exports.deserializeSchema = deserializeSchema;
 exports.extractValModules = extractValModules;
 exports.getSourcePathFromRoute = getSourcePathFromRoute;
+exports.hasRemoteFileSchema = hasRemoteFileSchema;
 exports.initVal = initVal;
 exports.modules = modules;
+exports.renderScope = renderScope;
 exports.splitModuleFilePathAndModulePath = splitModuleFilePathAndModulePath;