@lwrjs/core 0.8.0-alpha.2 → 0.8.0-alpha.5

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

@@ -1,406 +0,0 @@
-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/core/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

@@ -1,192 +0,0 @@
-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/core/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

@@ -1,34 +0,0 @@
-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/core/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

@@ -1,14 +0,0 @@
-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