@lwrjs/config 0.8.0-alpha.3

package/build/cjs/validation/app-config-context.cjs

@@ -0,0 +1,406 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/config/src/validation/app-config-context.ts
+__markAsModule(exports);
+__export(exports, {
+  ASSET_DIR_ATTRIBUTE_KEYS: () => ASSET_DIR_ATTRIBUTE_KEYS,
+  ASSET_FILE_ATTRIBUTE_KEYS: () => ASSET_FILE_ATTRIBUTE_KEYS,
+  BASE_PATH_REGEX: () => BASE_PATH_REGEX,
+  BOOTSTRAP_ATTRIBUTE_KEYS: () => BOOTSTRAP_ATTRIBUTE_KEYS,
+  ERROR_ROUTE_ATTRIBUTE_KEYS: () => ERROR_ROUTE_ATTRIBUTE_KEYS,
+  LOCKER_ATTRIBUTE_KEYS: () => LOCKER_ATTRIBUTE_KEYS,
+  ROOT_ATTRIBUTE_KEYS: () => ROOT_ATTRIBUTE_KEYS,
+  ROUTE_ATTRIBUTE_KEYS: () => ROUTE_ATTRIBUTE_KEYS,
+  ValidationContext: () => ValidationContext
+});
+var import_jsonc_parser = __toModule(require("jsonc-parser"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_helpers = __toModule(require("./helpers.cjs"));
+function createKeys(p, t) {
+  return p && t;
+}
+var ROOT_ATTRIBUTE_KEYS = createKeys("root", [
+  "amdLoader",
+  "apiVersion",
+  "assets",
+  "assetProviders",
+  "assetTransformers",
+  "bundleConfig",
+  "cacheDir",
+  "contentDir",
+  "environment",
+  "errorRoutes",
+  "esmLoader",
+  "staticSiteGenerator",
+  "globalData",
+  "globalDataDir",
+  "hooks",
+  "ignoreLwrConfigFile",
+  "lwrConfigFile",
+  "layoutsDir",
+  "locker",
+  "lwc",
+  "lwrVersion",
+  "moduleProviders",
+  "port",
+  "basePath",
+  "resourceProviders",
+  "rootDir",
+  "routes",
+  "serverMode",
+  "serverType",
+  "templateEngine",
+  "viewProviders",
+  "viewTransformers"
+]);
+var ASSET_DIR_ATTRIBUTE_KEYS = createKeys("assetDir", ["alias", "dir", "urlPath"]);
+var ASSET_FILE_ATTRIBUTE_KEYS = createKeys("assetFile", ["alias", "file", "urlPath"]);
+var LOCKER_ATTRIBUTE_KEYS = createKeys("locker", ["enabled", "trustedComponents", "clientOnly"]);
+var ROUTE_ATTRIBUTE_KEYS = createKeys("routes", [
+  "bootstrap",
+  "contentTemplate",
+  "id",
+  "cache",
+  "layoutTemplate",
+  "method",
+  "path",
+  "rootComponent",
+  "routeHandler",
+  "properties"
+]);
+var ERROR_ROUTE_ATTRIBUTE_KEYS = createKeys("errorRoutes", [
+  "bootstrap",
+  "contentTemplate",
+  "id",
+  "layoutTemplate",
+  "rootComponent",
+  "routeHandler",
+  "status",
+  "properties",
+  "cache"
+]);
+var BOOTSTRAP_ATTRIBUTE_KEYS = createKeys("bootstrap", [
+  "autoBoot",
+  "syntheticShadow",
+  "workers",
+  "services",
+  "configAsSrc",
+  "experimentalSSR"
+]);
+var SPECIFIER_REGEX = /^@?[\w-]+(\/[\w-]+)*$/;
+function isNotEmptyString(node) {
+  return node.type === "string" && node.value.length > 0;
+}
+var BASE_PATH_REGEX = /^(\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$/g;
+var ValidationContext = class {
+  constructor(sourceText) {
+    this.diagnostics = [];
+    this.sourceText = sourceText;
+  }
+  getLocationFromNode(node) {
+    return (0, import_helpers.calculatePositionFromSource)(this.sourceText, node);
+  }
+  assertIsObject(node, property) {
+    if (node.type !== "object") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "object", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsBoolean(node, property) {
+    if (node && node.type !== "boolean") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "boolean", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsArray(node, property) {
+    if (node && node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsSpecifier(node, property) {
+    if (node && (node.type !== "string" || !SPECIFIER_REGEX.test(node.value))) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SPECIFIER(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsPath(node, property) {
+    if (node && (node.type !== "string" || node.value[0] !== "/")) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_PATH(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsPort(node, property) {
+    if (node && (node.type !== "number" || node.value < 0 || node.value > 65353)) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_PORT(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsServerType(node, property) {
+    if (node && node.value !== "express" && node.value !== "koa" && node.value !== "fs") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SERVER_TYPE(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsStaticSiteGenerator(node, property) {
+    if (node && node.type !== "object") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_GENERATOR_CONFIG(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsMethod(node, property) {
+    if (node && node.value !== "get" && node.value !== "post") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_METHOD(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsStatus(node, property) {
+    if (node && node.value !== 404 && node.value !== 500) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_STATUS(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsEnvironment(node, property) {
+    if (!node) {
+      return;
+    }
+    let defaultProperty;
+    let supportedProperty;
+    if (node.type === "object" && node.children?.length) {
+      for (const child of node.children) {
+        if (child.type === "property" && child.children?.length) {
+          if (child.children[0].value === "default" && isNotEmptyString(child.children[1])) {
+            defaultProperty = child;
+          }
+          if (child.children[0].value === "supported") {
+            supportedProperty = child;
+          }
+        }
+      }
+    }
+    if (node.type !== "object" || supportedProperty && !defaultProperty) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_ENVIRONMENT(property),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertIsBasePath(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "string") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "string", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (node.value === "") {
+      return;
+    } else if (node.value.match(BASE_PATH_REGEX) === null) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_BASEPATH(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertNotEmptyString(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "string") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "string", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (!isNotEmptyString(node)) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.NON_EMPTY_STRING(property, node.value),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertNotEmptyArray(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (!node.children || node.children.length === 0) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.NON_EMPTY_ARRAY(property, "[]"),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertHasOneOrMore(node, property, childProps) {
+    if (!childProps.some((p) => (0, import_jsonc_parser.findNodeAtLocation)(node, [p]) !== void 0)) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.MISSING_ONE_OF(property, childProps),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertHasOnlyOne(node, property, childProps) {
+    if (childProps.filter((p) => (0, import_jsonc_parser.findNodeAtLocation)(node, [p])).length !== 1) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.TOO_MANY(property, childProps),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertArrayOfStrings(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (node.children && node.children.length > 0) {
+      node.children.forEach((n, index) => {
+        if (!isNotEmptyString(n)) {
+          this.diagnostics.push({
+            description: import_diagnostics.descriptions.CONFIG_PARSER.NON_EMPTY_STRING(`${property}[${index}]`, n.value),
+            location: this.getLocationFromNode(n)
+          });
+        }
+      });
+    }
+  }
+  assertArrayOfSpecifiers(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (node.children && node.children.length > 0) {
+      node.children.forEach((n, index) => {
+        if (n.type !== "string" || !SPECIFIER_REGEX.test(n.value)) {
+          this.diagnostics.push({
+            description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SPECIFIER(`${property}[${index}]`, n.value),
+            location: this.getLocationFromNode(n)
+          });
+        }
+      });
+    }
+  }
+  assertArrayOfServices(node, property) {
+    if (!node) {
+      return;
+    }
+    if (node.type !== "array") {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, "array", node.type),
+        location: this.getLocationFromNode(node)
+      });
+    } else if (node.children && node.children.length > 0) {
+      node.children.forEach((n, index) => {
+        if (n.type !== "string" && n.type !== "array") {
+          this.diagnostics.push({
+            description: import_diagnostics.descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(`${property}[${index}]`, "string or array", n.type),
+            location: this.getLocationFromNode(n)
+          });
+        }
+        if (n.type === "string" && n.value.length === 0 || n.type === "array" && n.children && (n.children.length !== 2 || !isNotEmptyString(n.children[0]))) {
+          this.diagnostics.push({
+            description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_SERVICE(`${property}[${index}]`, n.value === void 0 && n.children ? `invalid Array[${n.children.length}]` : n.value),
+            location: this.getLocationFromNode(n)
+          });
+        }
+      });
+    }
+  }
+  assertUniqueIds(nodes, property) {
+    const ids = nodes.map((n) => {
+      const idNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["id"]);
+      return idNode ? idNode.value : void 0;
+    }).filter((id) => id !== void 0);
+    const dupeIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+    if (dupeIds.length > 0) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.DUPLICATE_IDS(property, dupeIds),
+        location: this.getLocationFromNode(nodes[0])
+      });
+    }
+  }
+  assertRequiredKeys(node, property, requiredPropertyKeys) {
+    const missingProps = requiredPropertyKeys.filter((p) => (0, import_jsonc_parser.findNodeAtLocation)(node, [p]) === void 0);
+    if (missingProps.length > 0) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.MISSING_REQUIRED(property, missingProps),
+        location: this.getLocationFromNode(node)
+      });
+    }
+  }
+  assertValidKeys(node, property, validPropertyKeys) {
+    const {children} = node;
+    if (!children) {
+      this.diagnostics.push({
+        description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_EMPTY_NODE(property),
+        location: this.getLocationFromNode(node)
+      });
+      return;
+    } else {
+      for (const propertyNode of children) {
+        if (propertyNode.type === "property" && propertyNode.children) {
+          const [keyNode] = propertyNode.children;
+          const {type, value} = keyNode;
+          if (type === "string" && !validPropertyKeys.includes(value)) {
+            this.diagnostics.push({
+              description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_PROPERTY(property, value),
+              location: this.getLocationFromNode(keyNode)
+            });
+          }
+        }
+      }
+    }
+  }
+};

package/build/cjs/validation/app-config.cjs

@@ -0,0 +1,192 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/config/src/validation/app-config.ts
+__markAsModule(exports);
+__export(exports, {
+  SOURCE_BY_PHASE: () => SOURCE_BY_PHASE,
+  validateLwrAppConfig: () => validateLwrAppConfig
+});
+var import_jsonc_parser = __toModule(require("jsonc-parser"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var import_app_config_context = __toModule(require("./app-config-context.cjs"));
+var import_helpers = __toModule(require("./helpers.cjs"));
+var SOURCE_BY_PHASE = {
+  file: "lwr.config.json",
+  pre: "argument passed to createServer",
+  post: "configuration hooks"
+};
+function validateBootstrap(node, validationContext, propPrefix) {
+  if (node) {
+    validationContext.assertIsObject(node, "bootstrap");
+    validationContext.assertValidKeys(node, "bootstrap", import_app_config_context.BOOTSTRAP_ATTRIBUTE_KEYS);
+    validationContext.assertArrayOfSpecifiers((0, import_jsonc_parser.findNodeAtLocation)(node, ["services"]), `${propPrefix}.services`);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["autoBoot"]), `${propPrefix}.autoBoot`);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["experimentalSSR"]), `${propPrefix}.experimentalSSR`);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["configAsSrc"]), `${propPrefix}.configAsSrc`);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["syntheticShadow"]), `${propPrefix}.syntheticShadow`);
+    const workers = (0, import_jsonc_parser.findNodeAtLocation)(node, ["workers"]);
+    if (workers && workers.children) {
+      workers.children.forEach((w, index) => {
+        if (w.children && w.children.length > 1) {
+          validationContext.assertIsSpecifier(w.children[1], `${propPrefix}.workers[${index}]`);
+        }
+      });
+    }
+  }
+}
+function validateRouteCommon(node, validationContext, propPrefix) {
+  validationContext.assertHasOneOrMore(node, propPrefix, [
+    "rootComponent",
+    "contentTemplate",
+    "routeHandler"
+  ]);
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["id"]), `${propPrefix}.id`);
+  validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["rootComponent"]), `${propPrefix}.rootComponent`);
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["contentTemplate"]), `${propPrefix}.contentTemplate`);
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["layoutTemplate"]), `${propPrefix}.layoutTemplate`);
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["routeHandler"]), `${propPrefix}.routeHandler`);
+  validateBootstrap((0, import_jsonc_parser.findNodeAtLocation)(node, ["bootstrap"]), validationContext, `${propPrefix}.bootstrap`);
+}
+function validateRoutes(node, validationContext) {
+  if (node) {
+    validationContext.assertNotEmptyArray(node, "routes");
+    if (node.children) {
+      node.children.forEach((n, index) => {
+        const propPrefix = `routes[${index}]`;
+        validationContext.assertIsObject(n, "routes");
+        validationContext.assertValidKeys(n, "routes", import_app_config_context.ROUTE_ATTRIBUTE_KEYS);
+        validationContext.assertRequiredKeys(n, propPrefix, ["id", "path"]);
+        validationContext.assertIsPath((0, import_jsonc_parser.findNodeAtLocation)(n, ["path"]), `${propPrefix}.path`);
+        validationContext.assertIsMethod((0, import_jsonc_parser.findNodeAtLocation)(n, ["method"]), `${propPrefix}.method`);
+        validateRouteCommon(n, validationContext, propPrefix);
+      });
+    }
+  }
+}
+function validateErrorRoutes(node, validationContext) {
+  if (node) {
+    validationContext.assertIsArray(node, "errorRoutes");
+    if (node.children) {
+      node.children.forEach((n, index) => {
+        const propPrefix = `errorRoutes[${index}]`;
+        validationContext.assertIsObject(n, "errorRoutes");
+        validationContext.assertValidKeys(n, "errorRoutes", import_app_config_context.ERROR_ROUTE_ATTRIBUTE_KEYS);
+        validationContext.assertRequiredKeys(n, propPrefix, ["id", "status"]);
+        validationContext.assertIsStatus((0, import_jsonc_parser.findNodeAtLocation)(n, ["status"]), `${propPrefix}.status`);
+        validateRouteCommon(n, validationContext, propPrefix);
+      });
+    }
+  }
+}
+function validateAssets(node, validationContext, preMerge) {
+  if (node) {
+    if (preMerge && node.type === "string") {
+      validationContext.assertNotEmptyString(node, "assets");
+    } else {
+      validationContext.assertNotEmptyArray(node, "assets");
+      if (node.children) {
+        node.children.forEach((n, index) => {
+          const dirNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["dir"]);
+          const fileNode = (0, import_jsonc_parser.findNodeAtLocation)(n, ["file"]);
+          if (dirNode?.type === "string") {
+            validationContext.assertIsObject(n, "assetDir");
+            validationContext.assertValidKeys(n, "assetDir", import_app_config_context.ASSET_DIR_ATTRIBUTE_KEYS);
+          } else if (fileNode?.type === "string") {
+            validationContext.assertIsObject(n, "assetFile");
+            validationContext.assertValidKeys(n, "assetFile", import_app_config_context.ASSET_FILE_ATTRIBUTE_KEYS);
+          }
+          validationContext.assertRequiredKeys(n, `assets[${index}]`, ["urlPath"]);
+          validationContext.assertHasOnlyOne(n, `assets[${index}]`, ["dir", "file"]);
+          validationContext.assertNotEmptyString(dirNode, `assets[${index}].dir`);
+          validationContext.assertNotEmptyString(fileNode, `assets[${index}].file`);
+          validationContext.assertIsPath((0, import_jsonc_parser.findNodeAtLocation)(n, ["urlPath"]), `assets[${index}].urlPath`);
+          validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(n, ["alias"]), `assets[${index}].alias`);
+        });
+      }
+    }
+  }
+}
+function validateLocker(node, validationContext) {
+  if (node) {
+    validationContext.assertIsObject(node, "locker");
+    validationContext.assertValidKeys(node, "locker", import_app_config_context.LOCKER_ATTRIBUTE_KEYS);
+    validationContext.assertRequiredKeys(node, "locker", ["enabled"]);
+    validationContext.assertIsBoolean((0, import_jsonc_parser.findNodeAtLocation)(node, ["enabled"]), "locker.enabled");
+    validationContext.assertArrayOfStrings((0, import_jsonc_parser.findNodeAtLocation)(node, ["trustedComponents"]), "locker.trustedComponents");
+  }
+}
+function validateRoot(node, validationContext, preMerge) {
+  validationContext.assertIsObject(node, "root");
+  validationContext.assertValidKeys(node, "root", import_app_config_context.ROOT_ATTRIBUTE_KEYS);
+  !preMerge && validationContext.assertRequiredKeys(node, "root", import_app_config_context.ROOT_ATTRIBUTE_KEYS);
+  const routes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["routes"]);
+  const errorRoutes = (0, import_jsonc_parser.findNodeAtLocation)(node, ["errorRoutes"]);
+  validationContext.assertUniqueIds([...routes?.children || [], ...errorRoutes?.children || []], "routes");
+  validateRoutes(routes, validationContext);
+  validateErrorRoutes(errorRoutes, validationContext);
+  validateAssets((0, import_jsonc_parser.findNodeAtLocation)(node, ["assets"]), validationContext, preMerge);
+  validateLocker((0, import_jsonc_parser.findNodeAtLocation)(node, ["locker"]), validationContext);
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["apiVersion"]), "apiVersion");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["lwrVersion"]), "lwrVersion");
+  validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["amdLoader"]), "amdLoader");
+  validationContext.assertIsSpecifier((0, import_jsonc_parser.findNodeAtLocation)(node, ["esmLoader"]), "esmLoader");
+  validationContext.assertIsPort((0, import_jsonc_parser.findNodeAtLocation)(node, ["port"]), "port");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["serverMode"]), "serverMode");
+  validationContext.assertIsServerType((0, import_jsonc_parser.findNodeAtLocation)(node, ["serverType"]), "serverType");
+  validationContext.assertIsStaticSiteGenerator((0, import_jsonc_parser.findNodeAtLocation)(node, ["staticSiteGenerator"]), "staticSiteGenerator");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["rootDir"]), "rootDir");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["cacheDir"]), "cacheDir");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["contentDir"]), "contentDir");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["layoutsDir"]), "layoutsDir");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["globalDataDir"]), "globalDataDir");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["hooks"]), "hooks");
+  validationContext.assertNotEmptyString((0, import_jsonc_parser.findNodeAtLocation)(node, ["templateEngine"]), "templateEngine");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["moduleProviders"]), "moduleProviders");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["viewProviders"]), "viewProviders");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["resourceProviders"]), "resourceProviders");
+  validationContext.assertArrayOfServices((0, import_jsonc_parser.findNodeAtLocation)(node, ["assetProviders"]), "assetProviders");
+  validationContext.assertNotEmptyArray((0, import_jsonc_parser.findNodeAtLocation)(node, ["lwc", "modules"]), "lwc.modules");
+  validationContext.assertIsEnvironment((0, import_jsonc_parser.findNodeAtLocation)(node, ["environment"]), "environment");
+  validationContext.assertIsBasePath((0, import_jsonc_parser.findNodeAtLocation)(node, ["basePath"]), "basePath");
+}
+function validateLwrAppConfig(jsonSourceText, phase) {
+  const errors = [];
+  const preMerge = phase !== "post";
+  const rootNode = (0, import_jsonc_parser.parseTree)(jsonSourceText, errors);
+  if (errors.length) {
+    const {error, length, offset} = errors[0];
+    const message = (0, import_jsonc_parser.printParseErrorCode)(error);
+    const sourceLocation = (0, import_helpers.calculatePositionFromSource)(jsonSourceText, {length, offset});
+    throw (0, import_diagnostics.createSingleDiagnosticError)({
+      location: sourceLocation,
+      description: import_diagnostics.descriptions.CONFIG_PARSER.INVALID_JSON(message)
+    }, import_diagnostics.LwrConfigValidationError);
+  }
+  const validationContext = new import_app_config_context.ValidationContext(jsonSourceText);
+  validateRoot(rootNode, validationContext, preMerge);
+  if (validationContext.diagnostics.length) {
+    throw new import_diagnostics.LwrConfigValidationError(`Configuration validation errors in ${SOURCE_BY_PHASE[phase]}`, validationContext.diagnostics);
+  }
+  return (0, import_jsonc_parser.parse)(jsonSourceText);
+}

package/build/cjs/validation/helpers.cjs

@@ -0,0 +1,34 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+
+// packages/@lwrjs/config/src/validation/helpers.ts
+__markAsModule(exports);
+__export(exports, {
+  calculatePositionFromSource: () => calculatePositionFromSource
+});
+function calculatePositionFromSource(source, partialPosition) {
+  const lines = source.split("\n");
+  const {offset, length} = partialPosition;
+  let countedChars = 0;
+  for (const [index, line] of lines.entries()) {
+    const newLength = countedChars + line.length;
+    if (newLength >= offset - 1) {
+      return {
+        start: {
+          line: index + 1,
+          column: offset - countedChars
+        },
+        end: {
+          line: index + 1,
+          column: offset - countedChars + length
+        }
+      };
+    }
+    countedChars = newLength + 1;
+  }
+  throw new Error("Unable to calculate position from source: Unreachable offset");
+}

package/build/es/env-config.d.ts

@@ -0,0 +1,14 @@
+import { LwrGlobalConfig, NormalizedLwrGlobalConfig, ServerModeConfig } from '@lwrjs/types';
+export declare function explodeMode(mode: string): ServerModeConfig;
+/**
+ * Merge and normalize all LWR configurations.
+ *
+ * @remarks
+ * Configurations are merged in the following order:
+ *  defaults -> optional config file (lwr.config.json) -> optional config arg
+ *
+ * @param config - optional config supplied separate from the config file
+ * @returns the merged and normalized LWR configuration
+ */
+export declare function normalizeConfig(config?: LwrGlobalConfig): NormalizedLwrGlobalConfig;
+//# sourceMappingURL=env-config.d.ts.map