@lwrjs/core 0.8.0-alpha.4 → 0.8.0-alpha.7

package/build/cjs/env-config.cjs

@@ -0,0 +1,339 @@
+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/env-config.ts
+__markAsModule(exports);
+__export(exports, {
+  explodeMode: () => explodeMode,
+  normalizeConfig: () => normalizeConfig
+});
+var import_fs = __toModule(require("fs"));
+var import_path = __toModule(require("path"));
+var import_module = __toModule(require("module"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_package = __toModule(require("@lwrjs/core/package"));
+var import_app_config = __toModule(require("./validation/app-config.cjs"));
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
+var PORT = process.env.PORT ? parseInt(process.env.PORT, 10) : 3e3;
+var MODE = process.env.MODE || "dev";
+var DEFAULT_BASE_PATH = "";
+var DEFAULT_API_VERSION = "1";
+var LWR_VERSION = import_package.version;
+var DEFAULT_SERVER_TYPE = "express";
+var DEFAULT_LWR_CONFIG_JSON = "$rootDir/lwr.config.json";
+var DEFAULT_GENERATOR_CONFIG = {
+  outputDir: "__generated_site__",
+  locales: ["en-US"],
+  _additionalRoutePaths: []
+};
+var DEFAULT_ROOT_DIR = process.cwd();
+var DEFAULT_CACHE_FOLDER = "$rootDir/__lwr_cache__";
+var DEFAULT_ASSETS_DIR = "$rootDir/src/assets";
+var DEFAULT_CONTENT_DIR = "$rootDir/src/content";
+var DEFAULT_LAYOUTS_DIR = "$rootDir/src/layouts";
+var DEFAULT_DATA_DIR = "$rootDir/src/data";
+var DEFAULT_MODULE_PROVIDERS = [
+  "@lwrjs/app-service/moduleProvider",
+  "@lwrjs/lwc-ssr/moduleProvider",
+  "@lwrjs/router/module-provider",
+  "@lwrjs/lwc-module-provider",
+  "@lwrjs/npm-module-provider"
+];
+var DEFAULT_RESOURCE_PROVIDERS = ["@lwrjs/loader"];
+var DEFAULT_VIEW_PROVIDERS = [
+  "@lwrjs/nunjucks-view-provider",
+  "@lwrjs/html-view-provider",
+  "@lwrjs/markdown-view-provider",
+  "@lwrjs/base-view-provider"
+];
+var DEFAULT_VIEW_TRANFORM_PLUGINS = ["@lwrjs/base-view-transformer", "@lwrjs/lwc-ssr/viewTransformer"];
+var DEFAULT_ASSET_PROVIDERS = ["@lwrjs/fs-asset-provider"];
+var DEFAULT_ASSET_TRANFORM_PLUGINS = ["@lwrjs/asset-transformer"];
+var DEFAULT_TEMPLATE_ENGINE = "@lwrjs/base-template-engine";
+var DEFAULT_AMD_LOADER = "lwr/loader";
+var DEFAULT_AMD_LOADER_LEGACY = "lwr/loaderLegacy";
+var DEFAULT_ESM_LOADER = "lwr/esmLoader";
+var DEFAULT_SERVICE_PACKAGE_NAME = /lwr-(\w+)-service/;
+var DEFAULT_LWR_MODULES = [
+  {npm: getLWCEngineSpecifier()},
+  {npm: "@lwrjs/client-modules"},
+  {npm: "@lwrjs/loader"},
+  {npm: "@lwrjs/o11y"},
+  {npm: "@lwrjs/router"},
+  {npm: "@lwc/synthetic-shadow"}
+];
+var DEFAULT_BUNDLE_EXCLUSIONS = [
+  "lwc",
+  "@lwc/synthetic-shadow",
+  "lwr/navigation",
+  "lwr/esmLoader",
+  "lwr/profiler"
+];
+var DEFAULT_LWR_CONFIG = {
+  port: PORT,
+  ignoreLwrConfigFile: false,
+  lwrConfigFile: DEFAULT_LWR_CONFIG_JSON,
+  basePath: DEFAULT_BASE_PATH,
+  rootDir: DEFAULT_ROOT_DIR,
+  cacheDir: DEFAULT_CACHE_FOLDER,
+  serverMode: MODE,
+  apiVersion: DEFAULT_API_VERSION,
+  assets: DEFAULT_ASSETS_DIR,
+  assetProviders: DEFAULT_ASSET_PROVIDERS,
+  assetTransformers: DEFAULT_ASSET_TRANFORM_PLUGINS,
+  contentDir: DEFAULT_CONTENT_DIR,
+  layoutsDir: DEFAULT_LAYOUTS_DIR,
+  staticSiteGenerator: DEFAULT_GENERATOR_CONFIG,
+  globalDataDir: DEFAULT_DATA_DIR,
+  globalData: {},
+  hooks: [],
+  moduleProviders: DEFAULT_MODULE_PROVIDERS,
+  resourceProviders: DEFAULT_RESOURCE_PROVIDERS,
+  viewProviders: DEFAULT_VIEW_PROVIDERS,
+  viewTransformers: DEFAULT_VIEW_TRANFORM_PLUGINS,
+  templateEngine: DEFAULT_TEMPLATE_ENGINE,
+  environment: {},
+  lwc: {modules: []},
+  routes: [],
+  errorRoutes: [],
+  bundleConfig: {exclude: DEFAULT_BUNDLE_EXCLUSIONS},
+  serverType: DEFAULT_SERVER_TYPE,
+  locker: import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG
+};
+function createCacheFolder(cache, rootDir) {
+  const cacheDir = (0, import_shared_utils.normalizeDirectory)(cache, rootDir);
+  const absPath = import_path.default.resolve(cacheDir);
+  import_fs.default.mkdirSync(import_path.default.join(absPath, import_shared_utils.ASSETS_CACHE_DIR), {recursive: true});
+  return absPath;
+}
+function getLwrConfigFromFile(rootDir, customDir = DEFAULT_LWR_CONFIG_JSON) {
+  const lwrConfigPath = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(customDir, rootDir));
+  if (import_fs.default.existsSync(lwrConfigPath)) {
+    const configAsString = (0, import_shared_utils.readFile)(lwrConfigPath);
+    try {
+      return (0, import_app_config.validateLwrAppConfig)(configAsString, "file");
+    } catch (e) {
+      if (e instanceof import_diagnostics.LwrConfigValidationError) {
+        if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === "true") {
+          console.warn("ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution");
+          console.dir(e, {depth: null});
+          return JSON.parse(configAsString);
+        } else {
+          throw e;
+        }
+      }
+      return void 0;
+    }
+  } else {
+    console.log(`[Warning] LWR Config not found on "${lwrConfigPath}"`);
+    return void 0;
+  }
+}
+function explodeMode(mode) {
+  const modeConfigFile = import_path.default.join(import_package.rootPath, `./runtime-configs/${mode}.json`);
+  if (!import_fs.default.existsSync(modeConfigFile)) {
+    throw new Error(`No configuration found for server mode - ${mode}`);
+  }
+  const modeConfig = JSON.parse((0, import_shared_utils.readFile)(modeConfigFile));
+  return modeConfig;
+}
+function normalizeServices(services, rootDir) {
+  return services.map((service) => {
+    const [serviceName, serviceConfig = void 0] = Array.isArray(service) ? service : [service];
+    let rawServiceName = (0, import_shared_utils.normalizeDirectory)(serviceName, rootDir);
+    if (!rawServiceName.startsWith("@") && !DEFAULT_SERVICE_PACKAGE_NAME.test(rawServiceName)) {
+      rawServiceName = import_path.default.resolve(rawServiceName);
+    }
+    return [rawServiceName, serviceConfig];
+  });
+}
+function normalizeModules(modules, rootDir) {
+  return modules.map((m) => {
+    const dirRecord = m;
+    if (dirRecord.dir) {
+      dirRecord.dir = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(dirRecord.dir, rootDir));
+    }
+    const aliasRecord = m;
+    if (aliasRecord.path) {
+      aliasRecord.path = import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(aliasRecord.path, rootDir));
+    }
+    return m;
+  });
+}
+function normalizeRoutes(routes, resourcePaths) {
+  return routes.map((route) => {
+    const {routeHandler, contentTemplate, layoutTemplate} = route;
+    const bootstrap = {
+      ...import_shared_utils.DEFAULT_LWR_BOOTSTRAP_CONFIG,
+      ...route.bootstrap
+    };
+    return {
+      ...route,
+      bootstrap,
+      routeHandler: routeHandler && import_path.default.resolve((0, import_shared_utils.normalizeDirectory)(routeHandler, resourcePaths.rootDir)),
+      contentTemplate: contentTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(contentTemplate, resourcePaths)),
+      layoutTemplate: layoutTemplate && import_path.default.resolve((0, import_shared_utils.normalizeResourcePath)(layoutTemplate, resourcePaths))
+    };
+  });
+}
+function normalizeAssetsDir(assets, rootDir) {
+  if (typeof assets === "string") {
+    return [
+      {
+        alias: "assetsDir",
+        dir: (0, import_shared_utils.normalizeDirectory)(assets, rootDir),
+        urlPath: "/public/assets"
+      }
+    ];
+  } else {
+    return assets.map((asset) => {
+      const assetDir = asset.dir;
+      const assetFile = asset.file;
+      return {
+        ...asset,
+        dir: assetDir && (0, import_shared_utils.normalizeDirectory)(assetDir, rootDir),
+        file: assetFile && (0, import_shared_utils.normalizeDirectory)(assetFile, rootDir)
+      };
+    });
+  }
+}
+function mergeLWCConfigs(config1, config2) {
+  const modules1 = config1?.lwc?.modules || [];
+  const modules2 = config2?.lwc?.modules || [];
+  const interchangeable1 = config1?.lwc?.interchangeable || [];
+  const interchangeable2 = config2?.lwc?.interchangeable || [];
+  const mergedInterchangeable = [...interchangeable1, ...interchangeable2];
+  const interchangeableModules1 = config1?.lwc?.interchangeableModules || [];
+  const interchangeableModules2 = config2?.lwc?.interchangeableModules || [];
+  const mergedInterchangeableModules = [...interchangeableModules1, ...interchangeableModules2];
+  return {
+    modules: [...modules1, ...modules2],
+    interchangeable: mergedInterchangeable.length ? mergedInterchangeable : void 0,
+    interchangeableModules: mergedInterchangeableModules.length ? mergedInterchangeableModules : void 0
+  };
+}
+function mergeBundleConfig(jsonConfig, config) {
+  const defaultExclusions = config?.bundleConfig?.UNSAFE_lwrDefaultExclude || jsonConfig?.bundleConfig?.UNSAFE_lwrDefaultExclude || DEFAULT_BUNDLE_EXCLUSIONS;
+  const configExclusions = config?.bundleConfig?.exclude || jsonConfig?.bundleConfig?.exclude || [];
+  return {
+    ...jsonConfig?.bundleConfig,
+    ...config?.bundleConfig,
+    exclude: [...new Set([...defaultExclusions, ...configExclusions])]
+  };
+}
+function mergeLockerConfig(jsonConfig, config) {
+  const defaultNamespaces = import_shared_utils.DEFAULT_LOCKER_TRUSTED_CMP;
+  const configNamespaces = config?.locker?.trustedComponents || jsonConfig?.locker?.trustedComponents || [];
+  return {
+    ...import_shared_utils.DEFAULT_LWR_LOCKER_CONFIG,
+    ...jsonConfig?.locker,
+    ...config?.locker,
+    trustedComponents: [...new Set([...defaultNamespaces, ...configNamespaces])]
+  };
+}
+function getLWCEngineSpecifier() {
+  const require2 = (0, import_module.createRequire)(import_path.default.join(process.cwd(), "./env-config.js"));
+  const {version: version2} = require2("lwc/package.json");
+  if (version2 && version2.startsWith("1")) {
+    return "@lwc/engine";
+  }
+  return "@lwc/engine-dom";
+}
+function normalizeLwcConfig(config) {
+  return {
+    ...config,
+    interchangeableModulesMap: config.interchangeableModules ? (0, import_shared_utils.normalizeInterchangeableModuleConfig)(config.interchangeableModules) : void 0
+  };
+}
+function trimLwrConfig(config) {
+  Object.keys(config).forEach((k) => {
+    if (config[k] === void 0)
+      delete config[k];
+  });
+  return config;
+}
+function normalizeConfig(config) {
+  if (config !== void 0) {
+    config = trimLwrConfig(config);
+    try {
+      (0, import_app_config.validateLwrAppConfig)(JSON.stringify(config), "pre");
+    } catch (e) {
+      if (process.env.UNSAFE_IGNORE_CONFIG_VALIDATION === "true") {
+        console.warn("ignoring config validation errors due to UNSAFE_IGNORE_CONFIG_VALIDATION flag...proceed with caution");
+        console.dir(e, {depth: null});
+      } else {
+        throw e;
+      }
+    }
+  }
+  const rootDir = import_path.default.resolve(config?.rootDir || DEFAULT_ROOT_DIR);
+  const lwrJsonConfig = config?.ignoreLwrConfigFile === true ? void 0 : getLwrConfigFromFile(rootDir, config?.lwrConfigFile);
+  const mergedLwrGlobalConfig = {
+    ...DEFAULT_LWR_CONFIG,
+    ...lwrJsonConfig,
+    ...config,
+    lwc: normalizeLwcConfig(mergeLWCConfigs(lwrJsonConfig, config)),
+    bundleConfig: mergeBundleConfig(lwrJsonConfig, config),
+    locker: mergeLockerConfig(lwrJsonConfig, config),
+    staticSiteGenerator: {
+      ...DEFAULT_GENERATOR_CONFIG,
+      ...lwrJsonConfig?.staticSiteGenerator,
+      ...config?.staticSiteGenerator
+    },
+    rootDir
+  };
+  const assets = normalizeAssetsDir(mergedLwrGlobalConfig.assets, rootDir);
+  const contentDir = (0, import_shared_utils.normalizeDirectory)(mergedLwrGlobalConfig.contentDir, rootDir);
+  const layoutsDir = (0, import_shared_utils.normalizeDirectory)(mergedLwrGlobalConfig.layoutsDir, rootDir);
+  const amdLoader = (0, import_shared_utils.getFeatureFlags)().LEGACY_LOADER ? DEFAULT_AMD_LOADER_LEGACY : DEFAULT_AMD_LOADER;
+  return {
+    ...mergedLwrGlobalConfig,
+    assets,
+    contentDir,
+    layoutsDir,
+    globalDataDir: (0, import_shared_utils.normalizeDirectory)(mergedLwrGlobalConfig.globalDataDir, rootDir),
+    hooks: normalizeServices(mergedLwrGlobalConfig.hooks, rootDir),
+    cacheDir: createCacheFolder(mergedLwrGlobalConfig.cacheDir, rootDir),
+    lwc: {
+      modules: normalizeModules([...DEFAULT_LWR_MODULES, ...mergedLwrGlobalConfig.lwc.modules], rootDir),
+      interchangeable: mergedLwrGlobalConfig.lwc.interchangeable,
+      interchangeableModulesMap: mergedLwrGlobalConfig.lwc.interchangeableModulesMap
+    },
+    moduleProviders: normalizeServices(mergedLwrGlobalConfig.moduleProviders, rootDir),
+    assetProviders: normalizeServices(mergedLwrGlobalConfig.assetProviders, rootDir),
+    assetTransformers: normalizeServices(mergedLwrGlobalConfig.assetTransformers, rootDir),
+    resourceProviders: normalizeServices(mergedLwrGlobalConfig.resourceProviders, rootDir),
+    viewProviders: normalizeServices(mergedLwrGlobalConfig.viewProviders, rootDir),
+    viewTransformers: normalizeServices(mergedLwrGlobalConfig.viewTransformers, rootDir),
+    routes: normalizeRoutes(mergedLwrGlobalConfig.routes, {rootDir, assets, contentDir, layoutsDir}),
+    errorRoutes: normalizeRoutes(mergedLwrGlobalConfig.errorRoutes, {
+      rootDir,
+      assets,
+      contentDir,
+      layoutsDir
+    }),
+    amdLoader,
+    esmLoader: DEFAULT_ESM_LOADER,
+    lwrVersion: LWR_VERSION
+  };
+}

package/build/cjs/tools/static-generation.cjs

@@ -404,6 +404,8 @@ var ViewImportMetadataImpl = class {
   }
   mergeImportMetadata(targetImportMetdadata, newImportMetadata) {
     Object.assign(targetImportMetdadata.imports, newImportMetadata.imports);
-    Object.assign(targetImportMetdadata.index, newImportMetadata.index);
+    if (targetImportMetdadata.index) {
+      Object.assign(targetImportMetdadata.index, newImportMetadata.index || {});
+    }
   }
 };