@lwrjs/core 0.5.11-alpha.1 → 0.6.0-alpha.10

package/build/es/tools/static-generation.js

@@ -1,172 +1,16 @@
+import { getSpecifier, getExperimentalFeatures } from '@lwrjs/shared-utils';
 import { join, dirname, extname } from 'path';
 import fs from 'fs-extra';
 import { writeResponse } from './utils/stream.js';
 import { createDir, createResourceDir } from './utils/dir.js';
 export default class SiteGenerator {
-    async dispatchResourceRecursive(url, dispatcher, resourceOpts, siteConfig) {
-        const { outputDir, visitedUrls } = siteConfig;
-        if (!visitedUrls.has(url)) {
-            visitedUrls.add(url); // Maintain a list of visited urls here to avoid potential infinite loops
-            // Skip urls with path segment variables (i.e. '/custom/:bar')
-            // Users can specify specific urls via the '_additionalRoutePaths' config property
-            if (url.indexOf('/:') !== -1) {
-                console.error('Skipped url with variable path segment: ' + url);
-                return;
-            }
-            // Generate resource
-            const context = await dispatcher.dispatchUrl(url, 'GET', siteConfig.locale);
-            const { resourceType } = resourceOpts;
-            // -- Routes (root resources) -------
-            if (resourceType === 'route') {
-                const dir = createResourceDir(url, outputDir);
-                const localeDir = createResourceDir(url, join(outputDir, siteConfig.locale));
-                // TODO: We assume HTML, revisit this in the future
-                // This fails for routes configured with non-html file extensions.
-                // Example Route: "path": "/mixed_templates.md", (Configured as '/mixed_templates' would work)
-                //                "contentTemplate": "$contentDir/composed_markdown.md"
-                const filePath = join(dir, 'index.html');
-                const fileLocalePath = join(localeDir, 'index.html');
-                // Default Path (only write once)
-                // The default locale is english
-                if (siteConfig.locale.toLowerCase().startsWith('en')) {
-                    await writeResponse(context, filePath);
-                }
-                // Language path (always write out)
-                createDir(localeDir);
-                await writeResponse(context, fileLocalePath);
-                // Get the metadata
-                const viewDefinition = context.fs?.metadata?.viewDefinition;
-                if (viewDefinition) {
-                    // -- Dispatch dependencies
-                    const assets = viewDefinition.viewRecord.assetReferences || [];
-                    for (const asset of assets) {
-                        const assetUrl = asset.override?.uri || asset.url;
-                        // skip empty asset urls / data urls (i.e. <img src="" /> <img src="data:image/png;base64, iVBORw0..." />)
-                        if (assetUrl && !assetUrl.startsWith('data:')) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(assetUrl, dispatcher, { resourceType: 'asset', asset }, siteConfig);
-                        }
-                    }
-                    // Custom Elements
-                    const customElements = viewDefinition.viewRecord.customElements || [];
-                    for (const customElement of customElements) {
-                        const jsUris = Object.values(customElement.flatGraph.uriMap);
-                        for (const jsUri of jsUris) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
-                        }
-                    }
-                    // Bootstrap modules
-                    if (viewDefinition.viewRecord.bootstrapModule) {
-                        const boot = viewDefinition.viewRecord.bootstrapModule;
-                        const jsUris = Object.values(boot.flatGraph.uriMap);
-                        for (const jsUri of jsUris) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
-                        }
-                    }
-                    // Bootstrap Resources
-                    const bootstrapResources = viewDefinition.viewRecord.bootstrapModule?.resources || [];
-                    for (const resource of bootstrapResources) {
-                        // If resource is not inline download it for reference
-                        if (!resource.inline) {
-                            const resourceUri = resource.src || resource.specifier;
-                            if (resourceUri) {
-                                // eslint-disable-next-line no-await-in-loop
-                                await this.dispatchResourceRecursive(resourceUri, dispatcher, { resourceType: 'resource' }, siteConfig);
-                            }
-                            else {
-                                console.warn('Skipped inline bootstrap resource: %j', resource);
-                            }
-                        }
-                    }
-                    // Resources
-                    const resources = viewDefinition.viewRecord.resources || [];
-                    for (const resource of resources) {
-                        const resourceUri = resource.src || resource.specifier || '';
-                        if (resourceUri.startsWith('/')) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(resourceUri, dispatcher, { resourceType: 'resource' }, siteConfig);
-                        }
-                        else {
-                            console.warn('Skipped resource: %j', resource);
-                        }
-                    }
-                }
-                // -- Process Assets (css, images, ...) && Resources (lwr-loader-shim ...)
-            }
-            else if (resourceType === 'asset' || resourceType === 'resource') {
-                const normalizedUrl = decodeURIComponent(url);
-                createResourceDir(dirname(normalizedUrl), outputDir);
-                const fullPath = join(outputDir, normalizedUrl);
-                await writeResponse(context, fullPath);
-                // -- Process JS files
-            }
-            else if (resourceType === 'js') {
-                const normalizedUrl = decodeURIComponent(url);
-                createResourceDir(dirname(normalizedUrl), outputDir);
-                const ext = extname(normalizedUrl);
-                const fullPath = join(outputDir, `${normalizedUrl}${ext ? '' : '.js'}`);
-                await writeResponse(context, fullPath);
-                // Add URL re-writes for module redirects
-                if (normalizedUrl.indexOf('/s/') !== -1) {
-                    const rewriteUrl = normalizedUrl.substring(0, normalizedUrl.indexOf('/s/'));
-                    // Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6 -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
-                    siteConfig.urlRewriteMap.set(rewriteUrl, normalizedUrl);
-                    // Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr%2Fnavigation%2Fv%2F0_1_6 -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
-                    siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf('/s/')), normalizedUrl);
-                    // TODO Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
-                    // Dynamic import example /1/bundle/amd/l/en-US/bi/0/module/mi/dynamic%2Fmodule?importer=examples%2Fhome%2Fv%2F0_1_6
-                }
-                // Recursively traverse dependencies
-                const moduleDefinition = context.fs?.metadata.moduleDefinition; // LinkedModuleDefinition | BundleDefinition
-                if (moduleDefinition) {
-                    // Imports
-                    const imports = moduleDefinition.linkedModuleRecord?.imports ||
-                        moduleDefinition.bundleRecord?.imports ||
-                        [];
-                    // /1/module/esm/0/l/en-US/mi/lwc
-                    for (const importModule of imports) {
-                        const jsUri = importModule.specifier;
-                        if (jsUri.startsWith('/')) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
-                        }
-                        else {
-                            if (jsUri !== 'lwc')
-                                console.warn('Skipped import: ' + jsUri);
-                        }
-                    }
-                    // Dynamic imports
-                    const dynamicImports = moduleDefinition.linkedModuleRecord?.dynamicImports ||
-                        moduleDefinition.bundleRecord?.dynamicImports ||
-                        [];
-                    for (const importModule of dynamicImports) {
-                        const jsUri = importModule.specifier;
-                        if (jsUri.startsWith('/')) {
-                            // eslint-disable-next-line no-await-in-loop
-                            await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
-                        }
-                        else {
-                            console.warn('Skipped dynamic import: ' + jsUri);
-                        }
-                    }
-                }
-                // Bundles with unresolved module uris
-                const uris = context.fs?.metadata.resolvedUris || [];
-                for (const jsUri of uris) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
-                }
-            }
-        }
-    }
     /**
      * Build a static site in the configured directory
      *  - Generate all routes / modules
      *  - copy assets / resources
      *
-     * @param lwrApp
+     * @param config - LWR config for the site
+     * @param dispatcher - Facilitate server requests
      */
     async buildStaticApplication(config, dispatcher) {
         console.log('[Static Generation] starting');
@@ -175,34 +19,331 @@ export default class SiteGenerator {
             staticSiteGenerator.outputDir = '__generated_site__';
         }
         const outputDir = join(rootDir, staticSiteGenerator.outputDir);
+        console.log(`[INFO] Clear Output Location: ${outputDir}`);
+        fs.rmSync(outputDir, { recursive: true, force: true });
         const urlRewriteMap = new Map();
         // For each locale, generate all the modules
         await this.generateRoutes(staticSiteGenerator, routes, dispatcher, outputDir, urlRewriteMap);
         // Write redirect files
-        this.writeUrlMappings(outputDir, urlRewriteMap);
+        this.writeNetlifyRedirectConfig(outputDir, urlRewriteMap);
         // Copy over assets
         this.copyAssets(assets, outputDir);
         console.log('[Static Generation] complete');
     }
+    /**
+     * Crawl all view routes for a site
+     */
     async generateRoutes(staticSiteGenerator, routes, dispatcher, outputDir, urlRewriteMap = new Map()) {
         if (!staticSiteGenerator.locales) {
             staticSiteGenerator.locales = ['en-US'];
         }
+        // Build up a list of dispatch requests to kick off in parallel
+        const dispatchRequests = [];
+        const generateUrl = this.createGenerateURLFunction(dispatcher);
         for (const locale of staticSiteGenerator.locales) {
-            const visitedUrls = new Set();
             // Generate all the routes
             for (const route of routes) {
-                // eslint-disable-next-line no-await-in-loop
-                await this.dispatchResourceRecursive(route.path, dispatcher, { resourceType: 'route' }, { outputDir, visitedUrls, locale, urlRewriteMap });
+                const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap);
+                dispatchRequests.push(generateUrl(route.path, siteConfig));
             }
             // Generate any additional urls
             if (staticSiteGenerator._additionalRoutePaths) {
                 for (const uri of staticSiteGenerator._additionalRoutePaths) {
-                    // eslint-disable-next-line no-await-in-loop
-                    await this.dispatchResourceRecursive(uri, dispatcher, { resourceType: 'route' }, { outputDir, visitedUrls, locale, urlRewriteMap });
+                    const siteConfig = this.createSiteConfig(outputDir, locale, urlRewriteMap);
+                    dispatchRequests.push(generateUrl(uri, siteConfig));
                 }
             }
         }
+        // -- Dispatch routes
+        await Promise.all(dispatchRequests);
+    }
+    /**
+     * Creates a function to dispatch the root requests for a given view url
+     */
+    createGenerateURLFunction(dispatcher) {
+        const generateRoute = async (uri, siteConfig) => {
+            const locale = siteConfig.locale;
+            console.log(`[INFO] Start Generate: ${locale} ${uri}`);
+            // Kick off site generation for the current route
+            await this.dispatchResourceRecursive(uri, dispatcher, { resourceType: 'route' }, siteConfig);
+            // If there is a view config add any extra collected import metadata to the config
+            this.addAdditionalImportMetadataToViewConfig(siteConfig);
+            console.log(`[INFO] End Generate ${locale} ${uri}`);
+        };
+        return generateRoute.bind(this);
+    }
+    /**
+     * Primary recursive dispatch function.  Executes a URL and crawls its dependents.
+     *
+     * @param url - URL to execute
+     * @param dispatcher - Facilitates GET requests
+     * @param resourceOpts - Data about the URL to execute
+     * @param siteConfig - Running config for the current view
+     */
+    async dispatchResourceRecursive(url, dispatcher, resourceOpts, siteConfig) {
+        const { visitedUrls } = siteConfig;
+        if (!visitedUrls.has(url)) {
+            visitedUrls.add(url); // Maintain a list of visited urls here to avoid potential infinite loops
+            // Skip urls with path segment variables (i.e. '/custom/:bar')
+            // Users can specify specific urls via the '_additionalRoutePaths' config property
+            if (url.indexOf('/:') !== -1) {
+                console.error('Skipped url with variable path segment: ' + url);
+                return;
+            }
+            // Generate resource
+            const context = await dispatcher.dispatchUrl(url, 'GET', siteConfig.locale);
+            const { resourceType } = resourceOpts;
+            // -- Routes (root resources) -------
+            if (resourceType === 'route') {
+                await this.handleHtmlResource(url, context, siteConfig, dispatcher);
+                // -- Process Assets (css, images, ...) && Resources (lwr-loader-shim ...)
+            }
+            else if (resourceType === 'asset' || resourceType === 'resource') {
+                await this.handleAssetOrResource(url, context, siteConfig);
+                // -- Import Metadata Mappings
+            }
+            else if (resourceType == 'mapping') {
+                await this.handleMappingResource(url, context, siteConfig, dispatcher);
+                // -- Process JS files
+            }
+            else if (resourceType === 'js') {
+                await this.handleJavascriptResource(url, context, siteConfig, dispatcher);
+            }
+        }
+    }
+    /**
+     * Handle processing a returned javascript module or bundle and follow all returned references
+     * @param url - URL of the request javascript resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    async handleJavascriptResource(url, context, siteConfig, dispatcher) {
+        const { outputDir } = siteConfig;
+        const normalizedUrl = decodeURIComponent(url);
+        createResourceDir(dirname(normalizedUrl), outputDir);
+        const ext = extname(normalizedUrl);
+        const fullPath = join(outputDir, `${normalizedUrl}${ext ? '' : '.js'}`);
+        await writeResponse(context, fullPath);
+        // Build up a list of dispatch requests to kick off in parallel
+        const dispatchRequests = [];
+        // Add URL re-writes for module redirects
+        if (normalizedUrl.indexOf('/s/') !== -1) {
+            const rewriteUrl = normalizedUrl.substring(0, normalizedUrl.indexOf('/s/'));
+            // Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6 -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
+            siteConfig.urlRewriteMap.set(rewriteUrl, normalizedUrl);
+            // Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr%2Fnavigation%2Fv%2F0_1_6 -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
+            siteConfig.urlRewriteMap.set(url.substring(0, url.indexOf('/s/')), normalizedUrl);
+            // TODO Redirect /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation -> /1/bundle/amd/l/en-US/bi/0/module/mi/lwr/navigation/v/0_1_6/s/{signature}
+            // Dynamic import example /1/bundle/amd/l/en-US/bi/0/module/mi/dynamic%2Fmodule?importer=examples%2Fhome%2Fv%2F0_1_6
+        }
+        // Recursively traverse dependencies
+        const moduleDefinition = context.fs?.metadata?.moduleDefinition; // LinkedModuleDefinition | BundleDefinition
+        if (moduleDefinition) {
+            // Imports
+            const imports = moduleDefinition.linkedModuleRecord?.imports || moduleDefinition.bundleRecord?.imports || [];
+            // /1/module/esm/0/l/en-US/mi/lwc
+            for (const importModule of imports) {
+                const jsUri = getSpecifier(importModule);
+                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+            }
+            // Dynamic imports
+            const dynamicImports = moduleDefinition.linkedModuleRecord?.dynamicImports ||
+                moduleDefinition.bundleRecord?.dynamicImports ||
+                [];
+            for (const importModule of dynamicImports) {
+                const jsUri = getSpecifier(importModule);
+                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+            }
+        }
+        // Bundles with unresolved module uris
+        const uris = context.fs?.metadata?.resolvedUris || [];
+        for (const jsUri of uris) {
+            dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+        }
+        // -- Dispatch dependencies
+        await Promise.all(dispatchRequests);
+    }
+    /**
+     * Handle processing a returned module URI mapping resource and follow all returned references
+     * @param url - URL of the request mapping resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    async handleMappingResource(url, context, siteConfig, dispatcher) {
+        const { importMetadata: importMetatdata } = siteConfig;
+        const statusCode = context.response?.status;
+        // Received a server error
+        if (statusCode === 200) {
+            // Read JSON
+            const newImportMetadata = context.fs?.body;
+            if (!importMetatdata) {
+                console.warn('[WARN] Import metadata collector was never initialized');
+                return;
+            }
+            // Filter out and import metadata already included with the view
+            const filteredImportMetadata = importMetatdata.addAdditionalMetadata(newImportMetadata);
+            // Build up a list of dispatch requests to kick off in parallel
+            const dispatchRequests = [];
+            // Iterate through the import mappings and return request uris
+            for (const uri of Object.keys(filteredImportMetadata.imports)) {
+                dispatchRequests.push(this.dispatchResourceRecursive(uri, dispatcher, { resourceType: 'js' }, siteConfig));
+            }
+            // Wait for all requests to comeback
+            await Promise.all(dispatchRequests);
+        }
+        else {
+            const body = context.fs?.body;
+            console.warn(`[WARN] Failed to fetch ${url}: (${statusCode}) ${body}`);
+        }
+    }
+    /**
+     * Handle processing a returned HTML resource and process any provided view metadata
+     *
+     * @param url - URL of the requested HTML resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network Dispatcher
+     */
+    async handleHtmlResource(url, context, siteConfig, dispatcher) {
+        const { outputDir } = siteConfig;
+        const dir = createResourceDir(url, outputDir);
+        const localeDir = createResourceDir(url, join(outputDir, siteConfig.locale));
+        // TODO: We assume HTML, revisit this in the future
+        // This fails for routes configured with non-html file extensions.
+        // Example Route: "path": "/mixed_templates.md", (Configured as '/mixed_templates' would work)
+        //                "contentTemplate": "$contentDir/composed_markdown.md"
+        const filePath = join(dir, 'index.html');
+        const fileLocalePath = join(localeDir, 'index.html');
+        // Default Path (only write once)
+        // The default locale is english
+        if (siteConfig.locale.toLowerCase().startsWith('en')) {
+            await writeResponse(context, filePath);
+        }
+        // Language path (always write out)
+        createDir(localeDir);
+        await writeResponse(context, fileLocalePath);
+        // Get the metadata
+        const viewDefinition = context.fs?.metadata?.viewDefinition;
+        if (viewDefinition) {
+            // Process all references in the view
+            await this.handleViewDefinition(viewDefinition, siteConfig, dispatcher);
+        }
+    }
+    /**
+     * Handle processing a returned view definition by following all returned references
+     * @param viewDefinition - Metadata about everything directly referenced form the view
+     * @param siteConfig - Global metadata about the site
+     * @param dispatcher - Network dispatcher
+     */
+    async handleViewDefinition(viewDefinition, siteConfig, dispatcher) {
+        // Save mapping endpoint for future
+        siteConfig.endpoints = viewDefinition.viewRecord.endpoints;
+        // Save existing import metadata
+        if (viewDefinition.viewRecord.importMetadata) {
+            // Initialize import metadata collector
+            siteConfig.importMetadata = new ViewImportMetadataImpl(viewDefinition.viewRecord.importMetadata);
+        }
+        // Build up a list of dispatch requests to kick off in parallel
+        const dispatchRequests = [];
+        // Assets
+        const assets = viewDefinition.viewRecord.assetReferences || [];
+        for (const asset of assets) {
+            const assetUrl = asset.override?.uri || asset.url;
+            // skip empty asset urls / data urls (i.e. <img src="" /> <img src="data:image/png;base64, iVBORw0..." />)
+            if (assetUrl && !assetUrl.startsWith('data:')) {
+                dispatchRequests.push(this.dispatchResourceRecursive(assetUrl, dispatcher, { resourceType: 'asset', asset }, siteConfig));
+            }
+        }
+        // Custom Elements
+        const customElements = viewDefinition.viewRecord.customElements || [];
+        for (const customElement of customElements) {
+            const jsUris = Object.values(customElement.flatGraph.uriMap);
+            for (const jsUri of jsUris) {
+                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+            }
+        }
+        // Bootstrap modules
+        if (viewDefinition.viewRecord.bootstrapModule) {
+            const boot = viewDefinition.viewRecord.bootstrapModule;
+            const jsUris = Object.values(boot.flatGraph.uriMap);
+            for (const jsUri of jsUris) {
+                dispatchRequests.push(this.dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig));
+            }
+        }
+        // Bootstrap Resources
+        const bootstrapResources = viewDefinition.viewRecord.bootstrapModule?.resources || [];
+        for (const resource of bootstrapResources) {
+            // If resource is not inline download it for reference
+            if (!resource.inline) {
+                const resourceUri = resource.src || resource.specifier;
+                if (resourceUri) {
+                    dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, { resourceType: 'resource' }, siteConfig));
+                    // Rough identify if this is the config Uri and add it to the site config to store additional import metadata
+                    if (resourceUri.match(/\/application\/.*\/ai\/.*\/configuration/)) {
+                        siteConfig.viewConfigPath = this.getResourcePathFromUrl(siteConfig, resourceUri);
+                    }
+                }
+                else {
+                    console.warn('Skipped inline bootstrap resource: %j', resource);
+                }
+            }
+        }
+        // Resources
+        const resources = viewDefinition.viewRecord.resources || [];
+        for (const resource of resources) {
+            const resourceUri = resource.src || resource.specifier || '';
+            if (resourceUri.startsWith('/')) {
+                dispatchRequests.push(this.dispatchResourceRecursive(resourceUri, dispatcher, { resourceType: 'resource' }, siteConfig));
+            }
+            else {
+                console.warn('Skipped resource: %j', resource);
+            }
+        }
+        // -- Dispatch dependencies
+        await Promise.all(dispatchRequests);
+    }
+    async dispatchJSResourceRecursive(jsUri, dispatcher, siteConfig) {
+        if (jsUri.startsWith('/')) {
+            await this.dispatchResourceRecursive(jsUri, dispatcher, { resourceType: 'js' }, siteConfig);
+        }
+        else {
+            const supportsFingerprints = siteConfig.experimentalFeatures?.ENABLE_FINGERPRINTS;
+            if (supportsFingerprints) {
+                // Download mapping
+                const mappingEndpoint = siteConfig.endpoints?.uris?.mapping;
+                if (mappingEndpoint) {
+                    const mappingURL = siteConfig.endpoints?.uris?.mapping + encodeURIComponent(jsUri);
+                    await this.dispatchResourceRecursive(mappingURL, dispatcher, { resourceType: 'mapping' }, siteConfig);
+                }
+                else {
+                    console.warn('[WARN] Unable to fetch mapping for bare specifier or variable dynamic import: "' +
+                        jsUri +
+                        '"');
+                }
+            }
+            else {
+                console.warn('[WARN] Unable to resolve bare specifier or variable dynamic import: "' + jsUri + '"');
+            }
+        }
+    }
+    /**
+     * Handle processing a returned asset or resource
+     * @param url - URL of the requested asset or resource
+     * @param context - Response Context
+     * @param siteConfig - Global metadata about the site
+     */
+    async handleAssetOrResource(url, context, siteConfig) {
+        const fullPath = this.getResourcePathFromUrl(siteConfig, url);
+        await writeResponse(context, fullPath);
+    }
+    getResourcePathFromUrl(siteConfig, url) {
+        const { outputDir } = siteConfig;
+        const normalizedUrl = decodeURIComponent(url);
+        createResourceDir(dirname(normalizedUrl), outputDir);
+        const fullPath = join(outputDir, normalizedUrl);
+        return fullPath;
     }
     /**
      *  Write out redirect mapping files for static hosting services like netlify. Examples for why this is needed:
@@ -212,7 +353,7 @@ export default class SiteGenerator {
      * @param outputDir
      * @param urlRewriteMap
      */
-    writeUrlMappings(outputDir, urlRewriteMap) {
+    writeNetlifyRedirectConfig(outputDir, urlRewriteMap) {
         const serveJsonPath = join(outputDir, 'serve.json');
         const _redirectsPath = join(outputDir, '_redirects');
         if (fs.existsSync(_redirectsPath)) {
@@ -259,5 +400,97 @@ export default class SiteGenerator {
             }
         }
     }
+    /**
+     * Create a new site config for the current view
+     */
+    createSiteConfig(outputDir, locale, urlRewriteMap) {
+        const experimentalFeatures = this.filterExperimentalFeatures();
+        return {
+            outputDir,
+            visitedUrls: new Set(),
+            locale,
+            urlRewriteMap,
+            // Only include ENABLE_FINGERPRINTS if true
+            ...experimentalFeatures,
+        };
+    }
+    filterExperimentalFeatures() {
+        if (getExperimentalFeatures().ENABLE_FINGERPRINTS) {
+            return { experimentalFeatures: { ENABLE_FINGERPRINTS: true } };
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * Add any additional import metadata collected during static site generation to the Client Bootstrap Config for this view.
+     */
+    addAdditionalImportMetadataToViewConfig(siteConfig) {
+        const supportsFingerprints = siteConfig.experimentalFeatures?.ENABLE_FINGERPRINTS;
+        const additionalImportMetadata = siteConfig?.importMetadata?.getAdditionalImportMetadata();
+        if (supportsFingerprints &&
+            siteConfig.viewConfigPath &&
+            additionalImportMetadata?.imports &&
+            Object.keys(additionalImportMetadata.imports).length > 0) {
+            const imports = additionalImportMetadata.imports
+                ? JSON.stringify(additionalImportMetadata.imports)
+                : '{}';
+            const initImports = `if (!globalThis.LWR.imports) { globalThis.LWR.imports = {}; }`;
+            const mergeImports = `Object.assign(globalThis.LWR.imports, ${imports})`;
+            const index = additionalImportMetadata.index
+                ? JSON.stringify(additionalImportMetadata.index)
+                : '{}';
+            const initIndex = `if (!globalThis.LWR.index) { globalThis.LWR.index = {}; }`;
+            const mergeIndex = `Object.assign(globalThis.LWR.index, ${index})`;
+            fs.appendFileSync(siteConfig.viewConfigPath, `\n// Appended by Static Site Generator\n${initImports}\n${mergeImports}\n${initIndex}\n${mergeIndex}\n`);
+        }
+    }
+}
+// Class used to track import metadata for a view
+export class ViewImportMetadataImpl {
+    constructor(existingImportMetadata, additionalImportMetadata) {
+        this.existing = existingImportMetadata;
+        this.additional = additionalImportMetadata || { imports: {}, index: {} };
+    }
+    /**
+     * Get the additional import metadata collected while generating this view
+     * @returns
+     */
+    getAdditionalImportMetadata() {
+        return this.additional;
+    }
+    /**
+     * Adds any new imports found to the additional metadata map.  Returns a filtered
+     * map of imports not in the initial view
+     */
+    addAdditionalMetadata(newMetadata) {
+        const filteredImports = this.filterMetadata(newMetadata);
+        this.mergeImportMetadata(this.additional, filteredImports);
+        return filteredImports;
+    }
+    /**
+     * Filter out any existing import metadata the would have already been sent back with the view from set of additional metadata detected
+     */
+    filterMetadata(newMetadata) {
+        // Filter Imports
+        const importsArray = Object.entries(newMetadata.imports);
+        const filteredImports = importsArray.filter(([key]) => !this.existing.imports[key]);
+        const imports = Object.fromEntries(filteredImports);
+        // Filter Index
+        const indexArray = Object.entries(newMetadata.index || {});
+        const filteredIndex = indexArray.filter(([key]) => !this.existing.index || !this.existing.index[key]);
+        const index = Object.fromEntries(filteredIndex);
+        return {
+            imports,
+            index,
+        };
+    }
+    /**
+     * Merge new import metadata into target import metadata
+     */
+    mergeImportMetadata(targetImportMetdadata, newImportMetadata) {
+        Object.assign(targetImportMetdadata.imports, newImportMetadata.imports);
+        Object.assign(targetImportMetdadata.index, newImportMetadata.index);
+    }
 }
 //# sourceMappingURL=static-generation.js.map

package/build/es/tools/types.d.ts

@@ -1,6 +1,7 @@
+import { Endpoints, ExperimentalFeatures, ImportMetadata } from '@lwrjs/types';
 import { RenderedAssetReference } from '@lwrjs/types';
 export interface BaseResourceContextOpts {
-    resourceType: 'route' | 'asset' | 'js' | 'resource';
+    resourceType: 'route' | 'asset' | 'js' | 'resource' | 'mapping';
 }
 export interface RouteResourceOpts extends BaseResourceContextOpts {
     resourceType: 'route';
@@ -15,11 +16,30 @@ export interface JsResourceOpts extends BaseResourceContextOpts {
 export interface ResResourceOpts extends BaseResourceContextOpts {
     resourceType: 'resource';
 }
-export declare type ResourceContextOpts = RouteResourceOpts | AssetResourceOpts | JsResourceOpts | ResResourceOpts;
+export interface MappingResourceOpts extends BaseResourceContextOpts {
+    resourceType: 'mapping';
+}
+export declare type ResourceContextOpts = RouteResourceOpts | AssetResourceOpts | JsResourceOpts | ResResourceOpts | MappingResourceOpts;
+export interface ViewImportMetadata {
+    /**
+     * Get the additional import metadata collected while generating this view
+     * @returns
+     */
+    getAdditionalImportMetadata(): ImportMetadata;
+    /**
+     * Adds any new imports found to the additional metadata map.  Returns a filtered
+     * map of imports not in the initial view
+     */
+    addAdditionalMetadata(newMetadata: ImportMetadata): ImportMetadata;
+}
 export interface SiteConfig {
     outputDir: string;
     visitedUrls: Set<string>;
     locale: string;
     urlRewriteMap: Map<string, string>;
+    endpoints?: Endpoints;
+    importMetadata?: ViewImportMetadata;
+    viewConfigPath?: string;
+    experimentalFeatures?: ExperimentalFeatures;
 }
 //# sourceMappingURL=types.d.ts.map

package/build/es/tools/utils/network-dispatcher.d.ts

@@ -1,7 +1,10 @@
+/// <reference types="node" />
+import http from 'http';
 import { LwrDispatcher, FsContext } from '@lwrjs/types';
 export default class NetworkDispatcher implements LwrDispatcher {
     port: number;
     internalRequestKey: string;
+    pool: http.Agent;
     constructor(port: number, internalRequestKey: string);
     dispatchUrl(url: string, method: string, lang: string): Promise<FsContext>;
 }