@valbuild/shared 0.96.3 → 0.97.1

package/internal/dist/valbuild-shared-internal.cjs.prod.js

@@ -1023,16 +1023,22 @@ var SerializedStringSchema = zod.z.object({
     }).optional()
   }).optional(),
   opt: zod.z["boolean"](),
-  raw: zod.z["boolean"]()
+  raw: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedLiteralSchema = zod.z.object({
   type: zod.z.literal("literal"),
   value: zod.z.string(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedBooleanSchema = zod.z.object({
   type: zod.z.literal("boolean"),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedNumberSchema = zod.z.object({
   type: zod.z.literal("number"),
@@ -1040,20 +1046,26 @@ var SerializedNumberSchema = zod.z.object({
     max: zod.z.number().optional(),
     min: zod.z.number().optional()
   }).optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedObjectSchema = zod.z.lazy(function () {
   return zod.z.object({
     type: zod.z.literal("object"),
     items: zod.z.record(zod.z.string(), SerializedSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var SerializedArraySchema = zod.z.lazy(function () {
   return zod.z.object({
     type: zod.z.literal("array"),
     item: SerializedSchema,
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var SerializedUnionSchema = zod.z.lazy(function () {
@@ -1061,12 +1073,16 @@ var SerializedUnionSchema = zod.z.lazy(function () {
     type: zod.z.literal("union"),
     key: SerializedLiteralSchema,
     items: zod.z.array(SerializedLiteralSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   }), zod.z.object({
     type: zod.z.literal("union"),
     key: zod.z.string(),
     items: zod.z.array(SerializedObjectSchema),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   })]);
 });
 var ImageOptions = zod.z.object({
@@ -1078,7 +1094,9 @@ var ImageOptions = zod.z.object({
 var SerializedImageSchema = zod.z.object({
   type: zod.z.literal("image"),
   options: ImageOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var RichTextOptions = zod.z.lazy(function () {
   return zod.z.object({
@@ -1106,7 +1124,9 @@ var RichTextOptions = zod.z.lazy(function () {
 var SerializedRichTextSchema = zod.z.object({
   type: zod.z.literal("richtext"),
   options: RichTextOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
 var SerializedRecordSchema = zod.z.lazy(function () {
   return zod.z.object({
@@ -1120,7 +1140,9 @@ var SerializedRecordSchema = zod.z.lazy(function () {
     directory: zod.z.string().optional(),
     remote: zod.z["boolean"]().optional(),
     alt: SerializedSchema.optional(),
-    moduleMetadata: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.any())).optional()
+    moduleMetadata: zod.z.record(zod.z.string(), zod.z.record(zod.z.string(), zod.z.any())).optional(),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   }).passthrough();
 });
 var SerializedKeyOfSchema = zod.z.lazy(function () {
@@ -1136,7 +1158,9 @@ var SerializedKeyOfSchema = zod.z.lazy(function () {
       opt: zod.z["boolean"]().optional()
     })]).optional(),
     values: zod.z.union([zod.z.literal("string"), zod.z.array(zod.z.string())]),
-    opt: zod.z["boolean"]()
+    opt: zod.z["boolean"](),
+    readonly: zod.z["boolean"]().optional(),
+    hidden: zod.z["boolean"]().optional()
   });
 });
 var FileOptions = zod.z.object({
@@ -1145,11 +1169,31 @@ var FileOptions = zod.z.object({
 var SerializedFileSchema = zod.z.object({
   type: zod.z.literal("file"),
   options: FileOptions.optional(),
-  opt: zod.z["boolean"]()
+  opt: zod.z["boolean"](),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
+});
+var DateOptions = zod.z.object({
+  from: zod.z.string().optional(),
+  to: zod.z.string().optional()
 });
 var SerializedDateSchema = zod.z.object({
   type: zod.z.literal("date"),
-  opt: zod.z["boolean"]()
+  options: DateOptions.optional(),
+  opt: zod.z["boolean"](),
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional(),
+  description: zod.z.string().optional()
+});
+var SerializedDateTimeSchema = zod.z.object({
+  type: zod.z.literal("dateTime"),
+  options: DateOptions.optional(),
+  opt: zod.z["boolean"](),
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional(),
+  description: zod.z.string().optional()
 });
 var SerializedRouteSchema = zod.z.object({
   type: zod.z.literal("route"),
@@ -1165,9 +1209,11 @@ var SerializedRouteSchema = zod.z.object({
     customValidate: zod.z["boolean"]().optional()
   }).optional(),
   opt: zod.z["boolean"](),
-  customValidate: zod.z["boolean"]().optional()
+  customValidate: zod.z["boolean"]().optional(),
+  readonly: zod.z["boolean"]().optional(),
+  hidden: zod.z["boolean"]().optional()
 });
-var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedImageSchema]);
+var SerializedSchema = zod.z.union([SerializedStringSchema, SerializedLiteralSchema, SerializedBooleanSchema, SerializedNumberSchema, SerializedObjectSchema, SerializedArraySchema, SerializedUnionSchema, SerializedRichTextSchema, SerializedRecordSchema, SerializedKeyOfSchema, SerializedRouteSchema, SerializedFileSchema, SerializedDateSchema, SerializedDateTimeSchema, SerializedImageSchema]);
 
 var ValCommit = zod.z.object({
   commitSha: zod.z.string(),
@@ -1795,7 +1841,8 @@ var Api = {
         query: {
           validate_sources: onlyOneBooleanQueryParam.optional(),
           validate_binary_files: onlyOneBooleanQueryParam.optional(),
-          exclude_patches: onlyOneBooleanQueryParam.optional()
+          exclude_patches: onlyOneBooleanQueryParam.optional(),
+          apply_patches: onlyOneBooleanQueryParam.optional()
         },
         cookies: {
           val_session: zod.z.string().optional()
@@ -1832,7 +1879,7 @@ var Api = {
             source: zod.z.any().optional(),
             //.optional(), // TODO: Json zod type
             baseSource: zod.z.any().optional(),
-            // pre-patch source for compare view; set only when the module has pending patches
+            // pre-patch source for compare view; only set when the server applies patches (apply_patches=true) and the module has pending patches
             patches: zod.z.object({
               applied: zod.z.array(PatchId),
               skipped: zod.z.array(PatchId).optional(),
@@ -2748,8 +2795,384 @@ function createRegExpFromPattern(pattern) {
   }
 }
 
+var TYPE_ERROR_MESSAGE = "This is most likely a Val version mismatch or Val bug.";
+function getRoutesWithModulePaths(schemas, sources) {
+  var routeMap = new Map();
+  for (var moduleFilePathS in schemas) {
+    var moduleFilePath = moduleFilePathS;
+    var schema = schemas[moduleFilePath];
+    var source = sources[moduleFilePath];
+    if (schema && schema.type === "record" && schema.router && source && _typeof(source) === "object" && !Array.isArray(source)) {
+      for (var key in source) {
+        if (!routeMap.has(key)) {
+          routeMap.set(key, moduleFilePath);
+        }
+      }
+    }
+  }
+  var routes = Array.from(routeMap.entries()).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      route = _ref2[0],
+      moduleFilePath = _ref2[1];
+    return {
+      route: route,
+      moduleFilePath: moduleFilePath
+    };
+  });
+  return routes.sort(function (a, b) {
+    return a.route.localeCompare(b.route);
+  });
+}
+function getRoutesOf(schemas, sources) {
+  return getRoutesWithModulePaths(schemas, sources).map(function (r) {
+    return r.route;
+  });
+}
+
+// GPT generated levenshtein distance algorithm
+var levenshtein = function levenshtein(a, b) {
+  var _ref3 = [a.length, b.length],
+    m = _ref3[0],
+    n = _ref3[1];
+  if (!m || !n) return Math.max(m, n);
+  var dp = Array.from({
+    length: m + 1
+  }, function (_, i) {
+    return i;
+  });
+  for (var j = 1; j <= n; j++) {
+    var prev = dp[0];
+    dp[0] = j;
+    for (var i = 1; i <= m; i++) {
+      var 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, targets) {
+  return targets.map(function (target) {
+    return {
+      target: target,
+      distance: levenshtein(key, target)
+    };
+  }).sort(function (a, b) {
+    return a.distance - b.distance;
+  });
+}
+function getKeyOfRecordAt(sourcePath, snapshot) {
+  var _Internal$splitModule = core.Internal.splitModuleFilePathAndModulePath(sourcePath),
+    _Internal$splitModule2 = _slicedToArray(_Internal$splitModule, 2),
+    moduleFilePath = _Internal$splitModule2[0],
+    modulePath = _Internal$splitModule2[1];
+  var moduleSource = snapshot.sources[moduleFilePath];
+  var moduleSchema = snapshot.schemas[moduleFilePath];
+  if (!moduleSchema || moduleSource === undefined) {
+    return {
+      source: undefined,
+      schema: undefined
+    };
+  }
+  if (!modulePath) {
+    return {
+      source: moduleSource,
+      schema: moduleSchema
+    };
+  }
+  // Walk both schema and source. This intentionally only follows the
+  // patterns produced by keyOf().sourcePath — typically a top-level record or
+  // an object property pointing at a record. The walk is best-effort and
+  // returns undefined source on any mismatch.
+  var source = moduleSource;
+  var schema = moduleSchema;
+  var _iterator = _createForOfIteratorHelper(core.Internal.splitModulePath(modulePath)),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var part = _step.value;
+      if (source && _typeof(source) === "object" && !Array.isArray(source) && part in source) {
+        source = source[part];
+      } else {
+        source = undefined;
+      }
+      if (schema && schema.type === "object" && schema.items[part]) {
+        schema = schema.items[part];
+      } else if (schema && schema.type === "record") {
+        schema = schema.item;
+      } else {
+        schema = undefined;
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    source: source,
+    schema: schema
+  };
+}
+function checkKeyIsValid(key, sourcePath, snapshot) {
+  var _getKeyOfRecordAt = getKeyOfRecordAt(sourcePath, snapshot),
+    keyOfModuleSource = _getKeyOfRecordAt.source,
+    keyOfModuleSchema = _getKeyOfRecordAt.schema;
+  if (keyOfModuleSchema && keyOfModuleSchema.type !== "record") {
+    return {
+      error: true,
+      message: "Expected key at ".concat(sourcePath, " to be of type 'record'")
+    };
+  }
+  if (keyOfModuleSource && _typeof(keyOfModuleSource) === "object" && !Array.isArray(keyOfModuleSource) && key in keyOfModuleSource) {
+    return {
+      error: false
+    };
+  }
+  if (!keyOfModuleSource || _typeof(keyOfModuleSource) !== "object" || Array.isArray(keyOfModuleSource)) {
+    return {
+      error: true,
+      message: "Expected ".concat(sourcePath, " to be a truthy object")
+    };
+  }
+  var alternatives = findSimilar(key, Object.keys(keyOfModuleSource));
+  if (alternatives.length === 0) {
+    return {
+      error: true,
+      message: "Key '".concat(key, "' does not exist in ").concat(sourcePath, ".")
+    };
+  }
+  return {
+    error: true,
+    message: "Key '".concat(key, "' does not exist in ").concat(sourcePath, ". Closest match: '").concat(alternatives[0].target, "'. Other similar: ").concat(alternatives.slice(1, 4).map(function (a) {
+      return "'".concat(a.target, "'");
+    }).join(", ")).concat(alternatives.length > 4 ? ", ..." : "")
+  };
+}
+function checkRouteIsValid(route, includePattern, excludePattern, snapshot) {
+  var routerModules = {};
+  for (var moduleFilePathS in snapshot.schemas) {
+    var moduleFilePath = moduleFilePathS;
+    var schema = snapshot.schemas[moduleFilePath];
+    if ((schema === null || schema === void 0 ? void 0 : schema.type) === "record" && schema.router) {
+      var source = snapshot.sources[moduleFilePath];
+      if (source && _typeof(source) === "object" && !Array.isArray(source)) {
+        routerModules[moduleFilePath] = Object.keys(source);
+      }
+    }
+  }
+  var moduleEntries = Object.entries(routerModules);
+  var foundInModule = null;
+  for (var _i = 0, _moduleEntries = moduleEntries; _i < _moduleEntries.length; _i++) {
+    var _moduleEntries$_i = _slicedToArray(_moduleEntries[_i], 2),
+      _moduleFilePath = _moduleEntries$_i[0],
+      routes = _moduleEntries$_i[1];
+    if (routes.includes(route)) {
+      foundInModule = _moduleFilePath;
+      break;
+    }
+  }
+  if (!foundInModule) {
+    var allRoutes = moduleEntries.flatMap(function (_ref4) {
+      var _ref5 = _slicedToArray(_ref4, 2),
+        routes = _ref5[1];
+      return routes;
+    });
+    if (allRoutes.length === 0) {
+      return {
+        error: true,
+        message: "Route '".concat(route, "' could not be validated: No router modules found in the project. Use s.record(...).router(...) to define router modules.")
+      };
+    }
+    allRoutes = filterRoutesByPatterns(allRoutes, includePattern, excludePattern);
+    var alternatives = findSimilar(route, allRoutes);
+    return {
+      error: true,
+      message: "Route '".concat(route, "' does not exist in any router module. ").concat(alternatives.length > 0 ? "Closest match: '".concat(alternatives[0].target, "'. Other similar: ").concat(alternatives.slice(1, 4).map(function (a) {
+        return "'".concat(a.target, "'");
+      }).join(", ")).concat(alternatives.length > 4 ? ", ..." : "") : "No similar routes found.")
+    };
+  }
+  var patternValidation = validateRoutePatterns(route, includePattern, excludePattern);
+  if (!patternValidation.valid) {
+    return {
+      error: true,
+      message: patternValidation.message
+    };
+  }
+  return {
+    error: false
+  };
+}
+/**
+ * Resolves a single `keyof:check-keys` or `router:check-route` error against
+ * the given schema/source snapshot. Returns:
+ *   - null if the error is not one of these fixes (caller should pass through)
+ *   - { status: "resolved" } if the referenced key/route is valid (drop error)
+ *   - { status: "remaining"; error } if invalid (rewritten error to surface)
+ */
+function resolveSchemaSourceFixForError(error, snapshot) {
+  var _error$fixes;
+  var fixes = (_error$fixes = error.fixes) !== null && _error$fixes !== void 0 ? _error$fixes : [];
+  if (fixes.includes("keyof:check-keys")) {
+    if (!error.value) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Could not find a value for keyOf. ".concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (_typeof(error.value) !== "object") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error to have a 'value' property of type 'object'. Found: ".concat(_typeof(error.value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var valueObj = error.value;
+    var key = valueObj.key;
+    var valueSourcePath = valueObj.sourcePath;
+    if (typeof key !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error 'value' to have property 'key' of type 'string'. Found: ".concat(_typeof(key), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (typeof valueSourcePath !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected keyOf validation error 'value' to have property 'sourcePath' of type 'string'. Found: ".concat(_typeof(valueSourcePath), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var res = checkKeyIsValid(key, valueSourcePath, snapshot);
+    if (res.error) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: res.message,
+          fixes: undefined
+        })
+      };
+    }
+    return {
+      status: "resolved"
+    };
+  }
+  if (fixes.includes("router:check-route")) {
+    if (!error.value) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Could not find a value for route. ".concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    if (_typeof(error.value) !== "object") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected route validation error to have a 'value' property of type 'object'. Found: ".concat(_typeof(error.value), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var _valueObj = error.value;
+    var route = _valueObj.route;
+    if (typeof route !== "string") {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: "Expected route validation error 'value' to have property 'route' of type 'string'. Found: ".concat(_typeof(route), ". ").concat(TYPE_ERROR_MESSAGE),
+          typeError: true,
+          fixes: undefined
+        })
+      };
+    }
+    var include = asRegExpPattern(_valueObj.include);
+    var exclude = asRegExpPattern(_valueObj.exclude);
+    var _res = checkRouteIsValid(route, include, exclude, snapshot);
+    if (_res.error) {
+      return {
+        status: "remaining",
+        error: _objectSpread2(_objectSpread2({}, error), {}, {
+          message: _res.message,
+          fixes: undefined
+        })
+      };
+    }
+    return {
+      status: "resolved"
+    };
+  }
+  return null;
+}
+function asRegExpPattern(value) {
+  if (value && _typeof(value) === "object" && "source" in value && "flags" in value && typeof value.source === "string" && typeof value.flags === "string") {
+    return value;
+  }
+  return undefined;
+}
+
+/**
+ * Apply schema/source fix resolution across a map of validation errors.
+ *
+ * Errors with `keyof:check-keys` or `router:check-route` are resolved against
+ * the in-memory schema/source snapshot — valid references drop the error,
+ * invalid ones are rewritten with a "did you mean…" message and have their
+ * `fixes` cleared (so downstream code reports them as plain validation errors).
+ * All other errors pass through untouched.
+ *
+ * Source paths with no remaining errors are removed from the result.
+ */
+function resolveSchemaSourceFixes(validationErrors, snapshot) {
+  var result = {};
+  for (var sourcePathS in validationErrors) {
+    var sourcePath = sourcePathS;
+    var remaining = [];
+    var _iterator2 = _createForOfIteratorHelper(validationErrors[sourcePath]),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var error = _step2.value;
+        var resolved = resolveSchemaSourceFixForError(error, snapshot);
+        if (resolved === null) {
+          remaining.push(error);
+        } else if (resolved.status === "remaining") {
+          remaining.push(resolved.error);
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    if (remaining.length > 0) {
+      result[sourcePath] = remaining;
+    }
+  }
+  return result;
+}
+
 exports.Api = Api;
 exports.DEFAULT_ERROR_MESSAGE = DEFAULT_ERROR_MESSAGE;
+exports.DateOptions = DateOptions;
 exports.FileOptions = FileOptions;
 exports.ImageOptions = ImageOptions;
 exports.ParentRef = ParentRef$1;
@@ -2772,6 +3195,7 @@ exports.RichTextOptions = RichTextOptions;
 exports.SerializedArraySchema = SerializedArraySchema;
 exports.SerializedBooleanSchema = SerializedBooleanSchema;
 exports.SerializedDateSchema = SerializedDateSchema;
+exports.SerializedDateTimeSchema = SerializedDateTimeSchema;
 exports.SerializedFileSchema = SerializedFileSchema;
 exports.SerializedImageSchema = SerializedImageSchema;
 exports.SerializedKeyOfSchema = SerializedKeyOfSchema;
@@ -2795,12 +3219,18 @@ exports.ValDeployment = ValDeployment;
 exports.createRegExpFromPattern = createRegExpFromPattern;
 exports.createValClient = createValClient;
 exports.filterRoutesByPatterns = filterRoutesByPatterns;
+exports.findSimilar = findSimilar;
 exports.getErrorMessageFromUnknownJson = getErrorMessageFromUnknownJson;
 exports.getNextAppRouterSitemapTree = getNextAppRouterSitemapTree;
 exports.getNextAppRouterSourceFolder = getNextAppRouterSourceFolder;
 exports.getPatternFromModuleFilePath = getPatternFromModuleFilePath;
+exports.getRoutesOf = getRoutesOf;
+exports.getRoutesWithModulePaths = getRoutesWithModulePaths;
+exports.levenshtein = levenshtein;
 exports.parseRoutePattern = parseRoutePattern;
 exports.remirrorToRichTextSource = remirrorToRichTextSource;
+exports.resolveSchemaSourceFixForError = resolveSchemaSourceFixForError;
+exports.resolveSchemaSourceFixes = resolveSchemaSourceFixes;
 exports.richTextToRemirror = richTextToRemirror;
 exports.urlOf = urlOf;
 exports.validateRoutePatterns = validateRoutePatterns;