@lwrjs/config 0.8.0-alpha.3

package/build/es/validation/app-config-context.js

@@ -0,0 +1,391 @@
+import { findNodeAtLocation } from 'jsonc-parser';
+import { descriptions } from '@lwrjs/diagnostics';
+import { calculatePositionFromSource } from './helpers.js';
+// Run the duplicate and missing property checks against an object of a given type
+function createKeys(p, t) {
+    return p && t;
+}
+// These properties are kept in sync with the NormalizedLwrGlobalConfig type via ts checks
+export const 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',
+]);
+export const ASSET_DIR_ATTRIBUTE_KEYS = createKeys('assetDir', ['alias', 'dir', 'urlPath']);
+export const ASSET_FILE_ATTRIBUTE_KEYS = createKeys('assetFile', ['alias', 'file', 'urlPath']);
+export const LOCKER_ATTRIBUTE_KEYS = createKeys('locker', ['enabled', 'trustedComponents', 'clientOnly']);
+export const ROUTE_ATTRIBUTE_KEYS = createKeys('routes', [
+    'bootstrap',
+    'contentTemplate',
+    'id',
+    'cache',
+    'layoutTemplate',
+    'method',
+    'path',
+    'rootComponent',
+    'routeHandler',
+    'properties',
+]);
+export const ERROR_ROUTE_ATTRIBUTE_KEYS = createKeys('errorRoutes', [
+    'bootstrap',
+    'contentTemplate',
+    'id',
+    'layoutTemplate',
+    'rootComponent',
+    'routeHandler',
+    'status',
+    'properties',
+    'cache',
+]);
+export const BOOTSTRAP_ATTRIBUTE_KEYS = createKeys('bootstrap', [
+    'autoBoot',
+    'syntheticShadow',
+    'workers',
+    'services',
+    'configAsSrc',
+    'experimentalSSR',
+]);
+const SPECIFIER_REGEX = /^@?[\w-]+(\/[\w-]+)*$/;
+function isNotEmptyString(node) {
+    return node.type === 'string' && node.value.length > 0;
+}
+export const BASE_PATH_REGEX = /^(\/[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$/g;
+export class ValidationContext {
+    constructor(sourceText) {
+        this.diagnostics = [];
+        this.sourceText = sourceText;
+    }
+    getLocationFromNode(node) {
+        return calculatePositionFromSource(this.sourceText, node);
+    }
+    assertIsObject(node, property) {
+        if (node.type !== 'object') {
+            this.diagnostics.push({
+                description: 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: 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: 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: 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: 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: 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: 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: 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: 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: 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: descriptions.CONFIG_PARSER.INVALID_ENVIRONMENT(property),
+                location: this.getLocationFromNode(node),
+            });
+        }
+    }
+    assertIsBasePath(node, property) {
+        if (!node) {
+            return;
+        }
+        if (node.type !== 'string') {
+            this.diagnostics.push({
+                description: 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: 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: descriptions.CONFIG_PARSER.INCORRECT_NODE_TYPE(property, 'string', node.type),
+                location: this.getLocationFromNode(node),
+            });
+        }
+        else if (!isNotEmptyString(node)) {
+            this.diagnostics.push({
+                description: 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: 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: descriptions.CONFIG_PARSER.NON_EMPTY_ARRAY(property, '[]'),
+                location: this.getLocationFromNode(node),
+            });
+        }
+    }
+    assertHasOneOrMore(node, property, childProps) {
+        // At least one of the given child properties of node must exist
+        if (!childProps.some((p) => findNodeAtLocation(node, [p]) !== undefined)) {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.MISSING_ONE_OF(property, childProps),
+                location: this.getLocationFromNode(node),
+            });
+        }
+    }
+    assertHasOnlyOne(node, property, childProps) {
+        // One and ONLY one of the given child properties of node must exist
+        if (childProps.filter((p) => findNodeAtLocation(node, [p])).length !== 1) {
+            this.diagnostics.push({
+                description: 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: 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: 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: 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: 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: 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: 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: descriptions.CONFIG_PARSER.INVALID_SERVICE(`${property}[${index}]`, n.value === undefined && n.children
+                            ? `invalid Array[${n.children.length}]`
+                            : n.value),
+                        location: this.getLocationFromNode(n),
+                    });
+                }
+            });
+        }
+    }
+    assertUniqueIds(nodes, property) {
+        const ids = nodes
+            .map((n) => {
+            const idNode = findNodeAtLocation(n, ['id']);
+            return idNode ? idNode.value : undefined;
+        })
+            .filter((id) => id !== undefined);
+        const dupeIds = ids.filter((id, index) => ids.indexOf(id) !== index);
+        if (dupeIds.length > 0) {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.DUPLICATE_IDS(property, dupeIds),
+                location: this.getLocationFromNode(nodes[0]),
+            });
+        }
+    }
+    assertRequiredKeys(node, property, requiredPropertyKeys) {
+        // All of the given properties must exist on the node
+        const missingProps = requiredPropertyKeys.filter((p) => findNodeAtLocation(node, [p]) === undefined);
+        if (missingProps.length > 0) {
+            this.diagnostics.push({
+                description: descriptions.CONFIG_PARSER.MISSING_REQUIRED(property, missingProps),
+                location: this.getLocationFromNode(node),
+            });
+        }
+    }
+    assertValidKeys(node, property, validPropertyKeys) {
+        const { children } = node;
+        if (!children) {
+            this.diagnostics.push({
+                description: 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: descriptions.CONFIG_PARSER.INVALID_PROPERTY(property, value),
+                            location: this.getLocationFromNode(keyNode),
+                        });
+                    }
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=app-config-context.js.map

package/build/es/validation/app-config.d.ts

@@ -0,0 +1,10 @@
+import { LwrGlobalConfig } from '@lwrjs/types';
+export declare const SOURCE_BY_PHASE: {
+    file: string;
+    pre: string;
+    post: string;
+};
+declare type ConfigPhase = 'file' | 'pre' | 'post';
+export declare function validateLwrAppConfig(jsonSourceText: string, phase: ConfigPhase): LwrGlobalConfig;
+export {};
+//# sourceMappingURL=app-config.d.ts.map

package/build/es/validation/app-config.js

@@ -0,0 +1,245 @@
+import { parse, parseTree, printParseErrorCode, findNodeAtLocation as findNode, } from 'jsonc-parser';
+import { createSingleDiagnosticError, descriptions, LwrConfigValidationError } from '@lwrjs/diagnostics';
+import { ASSET_DIR_ATTRIBUTE_KEYS, ASSET_FILE_ATTRIBUTE_KEYS, BOOTSTRAP_ATTRIBUTE_KEYS, ERROR_ROUTE_ATTRIBUTE_KEYS, LOCKER_ATTRIBUTE_KEYS, ROOT_ATTRIBUTE_KEYS, ROUTE_ATTRIBUTE_KEYS, ValidationContext, } from './app-config-context.js';
+import { calculatePositionFromSource } from './helpers.js';
+export const SOURCE_BY_PHASE = {
+    file: 'lwr.config.json',
+    pre: 'argument passed to createServer',
+    post: 'configuration hooks',
+};
+/**
+ * Check config.routes[x].bootstrap:
+ *      - services: optional array of specifiers
+ *      - autoBoot: optional boolean
+ *      - syntheticShadow: optional boolean
+ *      - workers: optional map of string:specifier pairs
+ *      - configAsSrc: optional boolean to include the client bootstrap config as src via in-lined
+ */
+function validateBootstrap(node, validationContext, propPrefix) {
+    if (node) {
+        validationContext.assertIsObject(node, 'bootstrap');
+        validationContext.assertValidKeys(node, 'bootstrap', BOOTSTRAP_ATTRIBUTE_KEYS);
+        validationContext.assertArrayOfSpecifiers(findNode(node, ['services']), `${propPrefix}.services`);
+        validationContext.assertIsBoolean(findNode(node, ['autoBoot']), `${propPrefix}.autoBoot`);
+        validationContext.assertIsBoolean(findNode(node, ['experimentalSSR']), `${propPrefix}.experimentalSSR`);
+        validationContext.assertIsBoolean(findNode(node, ['configAsSrc']), `${propPrefix}.configAsSrc`);
+        validationContext.assertIsBoolean(findNode(node, ['syntheticShadow']), `${propPrefix}.syntheticShadow`);
+        // Each value in the worker map msut be a specifier
+        const workers = findNode(node, ['workers']);
+        if (workers && workers.children) {
+            workers.children.forEach((w, index) => {
+                if (w.children && w.children.length > 1) {
+                    // get the value in a map entry: { "key": "value" }
+                    validationContext.assertIsSpecifier(w.children[1], `${propPrefix}.workers[${index}]`);
+                }
+            });
+        }
+    }
+}
+/**
+ * Check common properties of config.routes[] and config.errorRoutes[]:
+ *      - id: required string
+ *      - each route must have at least 1 of the following:
+ *          - rootComponent
+ *          - contentTemplate
+ *          - routeHandler
+ *      - rootComponent: optional specifier
+ *      - contentTemplate: optional string
+ *      - layoutTemplate: optional string
+ *      - routeHandler: optional string
+ *      - optional bootstrap...
+ */
+function validateRouteCommon(node, validationContext, propPrefix) {
+    validationContext.assertHasOneOrMore(node, propPrefix, [
+        'rootComponent',
+        'contentTemplate',
+        'routeHandler',
+    ]);
+    validationContext.assertNotEmptyString(findNode(node, ['id']), `${propPrefix}.id`);
+    validationContext.assertIsSpecifier(findNode(node, ['rootComponent']), `${propPrefix}.rootComponent`);
+    validationContext.assertNotEmptyString(findNode(node, ['contentTemplate']), `${propPrefix}.contentTemplate`);
+    validationContext.assertNotEmptyString(findNode(node, ['layoutTemplate']), `${propPrefix}.layoutTemplate`);
+    validationContext.assertNotEmptyString(findNode(node, ['routeHandler']), `${propPrefix}.routeHandler`);
+    validateBootstrap(findNode(node, ['bootstrap']), validationContext, `${propPrefix}.bootstrap`);
+}
+/**
+ * Check config.routes[]:
+ *      - must have length > 0
+ *      - path: required path segment string
+ *      - method: optional 'get' | 'post'
+ */
+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', ROUTE_ATTRIBUTE_KEYS);
+                validationContext.assertRequiredKeys(n, propPrefix, ['id', 'path']);
+                validationContext.assertIsPath(findNode(n, ['path']), `${propPrefix}.path`);
+                validationContext.assertIsMethod(findNode(n, ['method']), `${propPrefix}.method`);
+                validateRouteCommon(n, validationContext, propPrefix);
+            });
+        }
+    }
+}
+/**
+ * Check config.errorRoutes[]:
+ *      - status: required 404 | 500
+ */
+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', ERROR_ROUTE_ATTRIBUTE_KEYS);
+                validationContext.assertRequiredKeys(n, propPrefix, ['id', 'status']);
+                validationContext.assertIsStatus(findNode(n, ['status']), `${propPrefix}.status`);
+                validateRouteCommon(n, validationContext, propPrefix);
+            });
+        }
+    }
+}
+/**
+ * Check string config.asset OR
+ * Check array config.assets[]:
+ *      - must have length > 0
+ *      - must have either dir or file, NOT both
+ *      - dir: optional string
+ *      - file: optional string
+ *      - urlPath: required path segment string
+ *      - alias: optional string
+ */
+function validateAssets(node, validationContext, preMerge) {
+    if (node) {
+        // assets can only be a string before the config is merged and normalized
+        if (preMerge && node.type === 'string') {
+            validationContext.assertNotEmptyString(node, 'assets');
+        }
+        else {
+            validationContext.assertNotEmptyArray(node, 'assets');
+            if (node.children) {
+                node.children.forEach((n, index) => {
+                    const dirNode = findNode(n, ['dir']);
+                    const fileNode = findNode(n, ['file']);
+                    if (dirNode?.type === 'string') {
+                        validationContext.assertIsObject(n, 'assetDir');
+                        validationContext.assertValidKeys(n, 'assetDir', ASSET_DIR_ATTRIBUTE_KEYS);
+                    }
+                    else if (fileNode?.type === 'string') {
+                        validationContext.assertIsObject(n, 'assetFile');
+                        validationContext.assertValidKeys(n, 'assetFile', 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(findNode(n, ['urlPath']), `assets[${index}].urlPath`);
+                    validationContext.assertNotEmptyString(findNode(n, ['alias']), `assets[${index}].alias`);
+                });
+            }
+        }
+    }
+}
+/**
+ * Check config.locker:
+ *      - enabled: required boolean
+ *      - trustedComponents: optional array of strings
+ */
+function validateLocker(node, validationContext) {
+    if (node) {
+        validationContext.assertIsObject(node, 'locker');
+        validationContext.assertValidKeys(node, 'locker', LOCKER_ATTRIBUTE_KEYS);
+        validationContext.assertRequiredKeys(node, 'locker', ['enabled']);
+        validationContext.assertIsBoolean(findNode(node, ['enabled']), 'locker.enabled');
+        validationContext.assertArrayOfStrings(findNode(node, ['trustedComponents']), 'locker.trustedComponents');
+    }
+}
+/**
+ * Check the normalized application configuration:
+ *      - post-normalization, all properties are required
+ *      - routes...
+ *      - errorRoutes...
+ *      - assets...
+ *      - route and errorRoute ids must be unique
+ *      - apiVersion: string
+ *      - lwrVersion: string
+ *      - amdLoader: specifier
+ *      - esmLoader: specifier
+ *      - port: number, 0 to 65353
+ *      - serverMode: string
+ *      - serverType: string
+ *      - rootDir, cacheDir, contentDir, layoutsDir, globalDataDir: strings
+ *      - hooks: array of strings
+ *      - templateEngine: string
+ *      - moduleProviders: array of services
+ *      - viewProviders: array of services
+ *      - resourceProviders: array of services
+ *      - assetProviders: array of services
+ *      - lwc.modules: array
+ *      - basePath: valid subdomain part
+ * Notes:
+ *      - ignore `bundleConfig` because it is not yet RFCed
+ *      - specifier strings are validated for type and shape only, NOT if they are resolvable
+ */
+function validateRoot(node, validationContext, preMerge) {
+    validationContext.assertIsObject(node, 'root');
+    validationContext.assertValidKeys(node, 'root', ROOT_ATTRIBUTE_KEYS);
+    !preMerge && validationContext.assertRequiredKeys(node, 'root', ROOT_ATTRIBUTE_KEYS);
+    const routes = findNode(node, ['routes']);
+    const errorRoutes = findNode(node, ['errorRoutes']);
+    validationContext.assertUniqueIds([...(routes?.children || []), ...(errorRoutes?.children || [])], 'routes');
+    validateRoutes(routes, validationContext);
+    validateErrorRoutes(errorRoutes, validationContext);
+    validateAssets(findNode(node, ['assets']), validationContext, preMerge);
+    validateLocker(findNode(node, ['locker']), validationContext);
+    validationContext.assertNotEmptyString(findNode(node, ['apiVersion']), 'apiVersion');
+    validationContext.assertNotEmptyString(findNode(node, ['lwrVersion']), 'lwrVersion');
+    validationContext.assertIsSpecifier(findNode(node, ['amdLoader']), 'amdLoader');
+    validationContext.assertIsSpecifier(findNode(node, ['esmLoader']), 'esmLoader');
+    validationContext.assertIsPort(findNode(node, ['port']), 'port');
+    validationContext.assertNotEmptyString(findNode(node, ['serverMode']), 'serverMode');
+    validationContext.assertIsServerType(findNode(node, ['serverType']), 'serverType');
+    validationContext.assertIsStaticSiteGenerator(findNode(node, ['staticSiteGenerator']), 'staticSiteGenerator');
+    validationContext.assertNotEmptyString(findNode(node, ['rootDir']), 'rootDir');
+    validationContext.assertNotEmptyString(findNode(node, ['cacheDir']), 'cacheDir');
+    validationContext.assertNotEmptyString(findNode(node, ['contentDir']), 'contentDir');
+    validationContext.assertNotEmptyString(findNode(node, ['layoutsDir']), 'layoutsDir');
+    validationContext.assertNotEmptyString(findNode(node, ['globalDataDir']), 'globalDataDir');
+    validationContext.assertArrayOfServices(findNode(node, ['hooks']), 'hooks');
+    validationContext.assertNotEmptyString(findNode(node, ['templateEngine']), 'templateEngine');
+    validationContext.assertArrayOfServices(findNode(node, ['moduleProviders']), 'moduleProviders');
+    validationContext.assertArrayOfServices(findNode(node, ['viewProviders']), 'viewProviders');
+    validationContext.assertArrayOfServices(findNode(node, ['resourceProviders']), 'resourceProviders');
+    validationContext.assertArrayOfServices(findNode(node, ['assetProviders']), 'assetProviders');
+    validationContext.assertNotEmptyArray(findNode(node, ['lwc', 'modules']), 'lwc.modules');
+    validationContext.assertIsEnvironment(findNode(node, ['environment']), 'environment');
+    validationContext.assertIsBasePath(findNode(node, ['basePath']), 'basePath');
+}
+export function validateLwrAppConfig(jsonSourceText, phase) {
+    const errors = [];
+    const preMerge = phase !== 'post'; // meaning the config has not yet been merged and normalized
+    const rootNode = parseTree(jsonSourceText, errors);
+    // Fatal error: JSON could not be parsed
+    if (errors.length) {
+        const { error, length, offset } = errors[0];
+        const message = printParseErrorCode(error);
+        const sourceLocation = calculatePositionFromSource(jsonSourceText, { length, offset });
+        throw createSingleDiagnosticError({
+            location: sourceLocation,
+            description: descriptions.CONFIG_PARSER.INVALID_JSON(message),
+        }, LwrConfigValidationError);
+    }
+    // Validate from root
+    const validationContext = new ValidationContext(jsonSourceText);
+    validateRoot(rootNode, validationContext, preMerge);
+    // Throw an error with all diagnostics at once
+    if (validationContext.diagnostics.length) {
+        throw new LwrConfigValidationError(`Configuration validation errors in ${SOURCE_BY_PHASE[phase]}`, validationContext.diagnostics);
+    }
+    return parse(jsonSourceText);
+}
+//# sourceMappingURL=app-config.js.map

package/build/es/validation/helpers.d.ts

@@ -0,0 +1,8 @@
+import { SourceLocation } from '@lwrjs/diagnostics';
+interface SourcePosition {
+    offset: number;
+    length: number;
+}
+export declare function calculatePositionFromSource(source: string, partialPosition: SourcePosition): SourceLocation;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/build/es/validation/helpers.js

@@ -0,0 +1,23 @@
+export 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');
+}
+//# sourceMappingURL=helpers.js.map