@ohos-ports/lwrjs-static 0.24.0-beta.1

package/build/es/site-metadata.d.ts

@@ -0,0 +1,80 @@
+import type { AbstractModuleId, I18NConfig, ResourceIdentifier, SiteAssets, SiteBundle, SiteBundles, SiteMetadata, SiteResource, SiteResources } from '@lwrjs/types';
+import DecisionTree from './utils/decision-tree.js';
+import { LOCALE_SIGIL, SSR_SIGIL, VERSION_SIGIL } from '@lwrjs/shared-utils';
+type Options = {
+    rootDir: string;
+    i18n: I18NConfig;
+};
+export declare const SITE_VERSION_PREFIX: string;
+export declare const SITE_LOCALE_PREFIX: string;
+export declare const SITE_SSR_PREFIX: string;
+type SIGIL = typeof VERSION_SIGIL | typeof SSR_SIGIL | typeof LOCALE_SIGIL;
+interface SiteArtifactId {
+    specifier: string;
+    variants: Record<SIGIL, string>;
+}
+export declare class SiteMetadataImpl implements SiteMetadata {
+    private options;
+    private siteBundles;
+    private debugSiteBundles;
+    private siteResources;
+    private debugSiteResources;
+    private siteAssets;
+    private bundleDecisionTree?;
+    private resourceDecisionTree?;
+    constructor(options: Options);
+    getSiteRootDir(): string;
+    getSiteBundles(): SiteBundles;
+    getDebugSiteBundles(): SiteBundles;
+    getSiteResources(): SiteResources;
+    getDebugSiteResources(): SiteResources;
+    getSiteAssets(): SiteAssets;
+    /**
+     * Returns a decision tree for site bundles in the form [debug, specifier, version, locale].
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteBundlesDecisionTree(): DecisionTree<SiteBundle>;
+    /**
+     * Returns a decision tree for site resources.
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteResourcesDecisionTree(): DecisionTree<SiteResource>;
+    persistSiteMetadata(): Promise<void>;
+    private readStaticBundleMetadata;
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    private readStaticResourceMetadata;
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    private readStaticAssetsMetadata;
+}
+/**
+ * Return the version for a static module bundle.
+ *
+ * Version defined in the metadata > Requested Version > 'version-not-provided'
+ */
+export declare function resolveStaticBundleVersion(metadataVersion?: string, requestedVersion?: string): string;
+/**
+ * Parse a site artifact ids string in the form specifier(|sigil(/value)?)*
+ */
+export declare function parseSiteId(input: string): SiteArtifactId;
+/**
+ * Get a  Site Bundle Identifier from a Root Module
+ *
+ * @param moduleId - Root Module Id
+ * @param locale - Current locale
+ * @param ssr - Component variant is required for SSR
+ * @returns Site Bundle Identifier
+ */
+export declare function getSiteBundleId({ specifier, namespace, name, version }: Partial<AbstractModuleId>, locale?: string, ssr?: boolean, i18n?: I18NConfig): string;
+/**
+ * Get a  Site Resource Identifier from a Resource Identifier
+ *
+ * @param resourceID -Resource Identifier
+ * @returns Site Bundle Identifier
+ */
+export declare function getSiteResourceId({ specifier, version }: Partial<ResourceIdentifier>): string;
+export {};
+//# sourceMappingURL=site-metadata.d.ts.map

package/build/es/site-metadata.js

@@ -0,0 +1,243 @@
+import path from 'path';
+import fs from 'fs-extra';
+import { logger } from '@lwrjs/diagnostics';
+import DecisionTree, { createFallbackMap } from './utils/decision-tree.js';
+import { LOCALE_SIGIL, SSR_SIGIL, VERSION_NOT_PROVIDED, VERSION_SIGIL, normalizeVersionToUri, } from '@lwrjs/shared-utils';
+const SITE_METADATA_PATH = '.metadata';
+const STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata.json');
+const DEBUG_STATIC_BUNDLE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/bundle-metadata-debug.json');
+const STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata.json');
+const DEBUG_STATIC_RESOURCE_METADATA_PATH = path.join(SITE_METADATA_PATH, '/resource-metadata-debug.json');
+const STATIC_ASSET_METADATA_PATH = path.join(SITE_METADATA_PATH, '/asset-metadata.json');
+export const SITE_VERSION_PREFIX = `|${VERSION_SIGIL}/`;
+export const SITE_LOCALE_PREFIX = `|${LOCALE_SIGIL}/`;
+export const SITE_SSR_PREFIX = `|${SSR_SIGIL}`;
+export class SiteMetadataImpl {
+    constructor(options) {
+        this.options = options;
+        this.siteBundles = this.readStaticBundleMetadata(options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+        this.debugSiteBundles = this.readStaticBundleMetadata(options.rootDir, DEBUG_STATIC_BUNDLE_METADATA_PATH);
+        this.siteResources = this.readStaticResourceMetadata(options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+        this.debugSiteResources = this.readStaticResourceMetadata(options.rootDir, DEBUG_STATIC_RESOURCE_METADATA_PATH);
+        this.siteAssets = this.readStaticAssetsMetadata(options.rootDir, STATIC_ASSET_METADATA_PATH);
+    }
+    getSiteRootDir() {
+        return this.options.rootDir;
+    }
+    getSiteBundles() {
+        return this.siteBundles;
+    }
+    getDebugSiteBundles() {
+        return this.debugSiteBundles;
+    }
+    getSiteResources() {
+        return this.siteResources;
+    }
+    getDebugSiteResources() {
+        return this.debugSiteResources;
+    }
+    getSiteAssets() {
+        return this.siteAssets;
+    }
+    /**
+     * Returns a decision tree for site bundles in the form [debug, specifier, version, locale].
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteBundlesDecisionTree() {
+        if (!this.bundleDecisionTree) {
+            this.bundleDecisionTree = new DecisionTree();
+            // Normalize i18NConfig fallback paths
+            const localeFallbacks = createFallbackMap(this.options.i18n);
+            // Add All the Bundles path keys [specifier][prod][version? (version || '') : ('' || '*')][localeId || fallbacks]
+            for (const [key, bundle] of Object.entries(this.siteBundles.bundles)) {
+                this.bundleDecisionTree.insert(key, bundle, false, localeFallbacks);
+            }
+            // Add All the Bundles path keys [specifier][debug][[version? (version || '') : ('' || '*')][localeId || fallbacks]
+            for (const [key, bundle] of Object.entries(this.debugSiteBundles.bundles)) {
+                this.bundleDecisionTree.insert(key, bundle, true, localeFallbacks);
+            }
+        }
+        return this.bundleDecisionTree;
+    }
+    /**
+     * Returns a decision tree for site resources.
+     * It is assumed this is static after creation subsequent calls will return the same instance.
+     */
+    getSiteResourcesDecisionTree() {
+        if (!this.resourceDecisionTree) {
+            this.resourceDecisionTree = new DecisionTree();
+            // Add All the prod resources path keys [specifier][prod][version? (version || '') : ('' || '*')][*]
+            for (const [key, resource] of Object.entries(this.siteResources.resources)) {
+                this.resourceDecisionTree.insert(key, resource, false);
+            }
+            // Add All the debug resources path keys [specifier][debug][version? (version || '') : ('' || '*')][*]
+            for (const [key, resource] of Object.entries(this.debugSiteResources.resources)) {
+                this.resourceDecisionTree.insert(key, resource, true);
+            }
+        }
+        return this.resourceDecisionTree;
+    }
+    async persistSiteMetadata() {
+        // Create the metadata directory if if does not exist
+        const siteMetadataPath = path.join(this.options.rootDir, SITE_METADATA_PATH);
+        if (siteMetadataPath.indexOf('__skip_directory_creation__') !== -1)
+            return;
+        try {
+            if (!fs.existsSync(siteMetadataPath)) {
+                await fs.mkdir(siteMetadataPath, { recursive: true });
+            }
+            // Save Bundle Metadata
+            const bundleMetadataPath = path.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+            await fs.writeJSON(bundleMetadataPath, this.siteBundles, { spaces: 2 });
+            // Save Debug Bundle Metadata
+            const debugBundleMetadataPath = path.join(this.options.rootDir, DEBUG_STATIC_BUNDLE_METADATA_PATH);
+            await fs.writeJSON(debugBundleMetadataPath, this.debugSiteBundles, { spaces: 2 });
+            // Save Resource Metadata
+            const resourceMetadataPath = path.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+            await fs.writeJSON(resourceMetadataPath, this.siteResources, { spaces: 2 });
+            // Save Debug Resource Metadata
+            const debugResourceMetadataPath = path.join(this.options.rootDir, DEBUG_STATIC_RESOURCE_METADATA_PATH);
+            await fs.writeJSON(debugResourceMetadataPath, this.debugSiteResources, { spaces: 2 });
+            // Save Resource Metadata
+            const assetMetadataPath = path.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+            return fs.writeJSON(assetMetadataPath, this.siteAssets, { spaces: 2 });
+        }
+        catch (err) {
+            logger.error(`[SiteMetadata] Failed to save site metadata ${siteMetadataPath}`);
+            logger.error(err);
+        }
+    }
+    readStaticBundleMetadata(staticRoot, metadataPath) {
+        let bundleMetadataPath;
+        let siteBundles = { bundles: {} };
+        try {
+            bundleMetadataPath = path.join(staticRoot, metadataPath);
+            const savedMetadata = fs.readJSONSync(bundleMetadataPath);
+            siteBundles = savedMetadata;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug({
+                    label: `SiteMetadata`,
+                    message: `Failed to load Static Bundle Metadata: ${bundleMetadataPath}`,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteBundles;
+    }
+    /**
+     * Read the metadata about the pre-built resources of the current site.
+     */
+    readStaticResourceMetadata(staticRoot, metadataPath) {
+        let resourceMetadataPath;
+        let siteResources = { resources: {} };
+        try {
+            resourceMetadataPath = path.join(staticRoot, metadataPath);
+            const savedMetadata = fs.readJSONSync(resourceMetadataPath);
+            siteResources = savedMetadata;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug({
+                    label: `SiteMetadata`,
+                    message: `Failed to load Static Resource Metadata: ${resourceMetadataPath}`,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteResources;
+    }
+    /**
+     * Read the metadata about the pre-built assets of the current site.
+     */
+    readStaticAssetsMetadata(staticRoot, metadataPath) {
+        let assetMetadataPath;
+        let siteAssets = {
+            assets: {},
+        };
+        try {
+            assetMetadataPath = path.join(staticRoot, metadataPath);
+            siteAssets = fs.readJSONSync(assetMetadataPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                logger.debug({
+                    label: `SiteMetadata`,
+                    message: `Failed to load Static Resource Metadata: ${assetMetadataPath}`,
+                });
+            }
+            else {
+                throw error;
+            }
+        }
+        return siteAssets;
+    }
+}
+/**
+ * Return the version for a static module bundle.
+ *
+ * Version defined in the metadata > Requested Version > 'version-not-provided'
+ */
+export function resolveStaticBundleVersion(metadataVersion, requestedVersion) {
+    return metadataVersion || requestedVersion || VERSION_NOT_PROVIDED;
+}
+/**
+ * Parse a site artifact ids string in the form specifier(|sigil(/value)?)*
+ */
+export function parseSiteId(input) {
+    const parts = input.split('|');
+    const specifier = parts[0];
+    const variants = {};
+    // Process each variant part after the first element
+    for (let i = 1; i < parts.length; i++) {
+        const [sigil, value] = parts[i].split('/');
+        if (sigil && value) {
+            variants[sigil] = value;
+        }
+        else if (sigil) {
+            variants[sigil] = 'true';
+        }
+    }
+    return {
+        specifier: specifier,
+        variants: variants,
+    };
+}
+/**
+ * Get a  Site Bundle Identifier from a Root Module
+ *
+ * @param moduleId - Root Module Id
+ * @param locale - Current locale
+ * @param ssr - Component variant is required for SSR
+ * @returns Site Bundle Identifier
+ */
+export function getSiteBundleId({ specifier, namespace, name = '', version }, locale, ssr, i18n) {
+    if (!specifier) {
+        specifier = namespace ? `${namespace}/${name}` : name;
+    }
+    // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+    const versionedSpecifier = version && version !== VERSION_NOT_PROVIDED
+        ? `${specifier}${SITE_VERSION_PREFIX}${normalizeVersionToUri(version)}`
+        : specifier;
+    const ssrSpecifier = ssr ? `${versionedSpecifier}${SITE_SSR_PREFIX}` : versionedSpecifier;
+    return i18n?.defaultLocale === locale ? ssrSpecifier : `${ssrSpecifier}${SITE_LOCALE_PREFIX}${locale}`;
+}
+/**
+ * Get a  Site Resource Identifier from a Resource Identifier
+ *
+ * @param resourceID -Resource Identifier
+ * @returns Site Bundle Identifier
+ */
+export function getSiteResourceId({ specifier, version }) {
+    // If a module has an explicit 'version-not-provided' version this will not be reflected in the specifier
+    const versionedSpecifier = version && version !== VERSION_NOT_PROVIDED
+        ? `${specifier}${SITE_VERSION_PREFIX}${normalizeVersionToUri(version)}`
+        : specifier;
+    return versionedSpecifier;
+}
+//# sourceMappingURL=site-metadata.js.map

package/build/es/tools/dedupe-bundles.d.ts

@@ -0,0 +1,3 @@
+import type { I18NConfig } from '@lwrjs/types';
+export declare function dedupeBundles(rootDir: string, i18n: I18NConfig): Promise<void>;
+//# sourceMappingURL=dedupe-bundles.d.ts.map

package/build/es/tools/dedupe-bundles.js

@@ -0,0 +1,89 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { logger } from '@lwrjs/diagnostics';
+import { SiteMetadataImpl, parseSiteId } from '../site-metadata.js';
+import { LOCALE_SIGIL, hashContent, joinUrlPath } from '@lwrjs/shared-utils';
+export async function dedupeBundles(rootDir, i18n) {
+    const siteMetadata = new SiteMetadataImpl({
+        rootDir,
+        i18n,
+    });
+    const siteBundles = siteMetadata.getSiteBundles();
+    const decisionTree = siteMetadata.getSiteBundlesDecisionTree();
+    logger.info({
+        label: `dedupeBundles`,
+        message: `Deduplicating ${Object.keys(siteBundles.bundles).length} bundles`,
+    });
+    for (const [siteIdStr, metadata] of Object.entries(siteBundles.bundles)) {
+        const siteId = parseSiteId(siteIdStr);
+        const localeId = siteId.variants[LOCALE_SIGIL];
+        // If this is already the default locale has no fall backs skip
+        if (!localeId || localeId === i18n.defaultLocale) {
+            continue;
+        }
+        // Read the content from the current metadata
+        const currentPath = joinUrlPath(rootDir, metadata.path);
+        const currentSrc = fs.readFileSync(currentPath);
+        logger.debug({
+            label: `dedupeBundles`,
+            message: `${siteIdStr} -> ${hashContent(currentSrc)}`,
+        });
+        // Find the current locale
+        const locale = i18n.locales.find((l) => l.id === localeId);
+        const fallBackLocale = locale?.fallback ?? i18n.defaultLocale;
+        const fallbackMetadata = decisionTree.find(siteIdStr, false, false, fallBackLocale);
+        if (fallbackMetadata) {
+            // Read the content of the fallback metadata
+            const fallbackSrc = fs.readFileSync(joinUrlPath(rootDir, fallbackMetadata.path));
+            logger.debug({
+                label: `dedupeBundles`,
+                message: `fallback ${siteIdStr},${fallBackLocale} -> ${hashContent(fallbackSrc)}`,
+            });
+            if (currentSrc.equals(fallbackSrc)) {
+                logger.debug({
+                    label: `dedupeBundles`,
+                    message: `Remove duplicate variant ${siteIdStr}`,
+                });
+                delete siteBundles.bundles[siteIdStr];
+                // Do not remove the file if it is the same path as the fallback
+                if (metadata.path != fallbackMetadata.path) {
+                    fs.removeSync(currentPath);
+                }
+            }
+        }
+    }
+    logger.info({
+        label: `dedupeBundles`,
+        message: `Deduplicated down to ${Object.keys(siteBundles.bundles).length} bundles`,
+    });
+    // Save the updated bundle metadata
+    await siteMetadata.persistSiteMetadata();
+    // Clean up empty folders
+    deleteEmptyFolders(rootDir);
+}
+function deleteEmptyFolders(directory) {
+    if (!fs.existsSync(directory)) {
+        logger.warn({ label: `dedupeBundles`, message: `Directory does not exist: ${directory}` });
+        return;
+    }
+    const files = fs.readdirSync(directory);
+    if (files.length === 0) {
+        fs.rmdirSync(directory);
+        logger.debug({ label: `dedupeBundles`, message: `Deleted empty folder: ${directory}` });
+        return;
+    }
+    files.forEach((file) => {
+        const filePath = path.join(directory, file);
+        const isDirectory = fs.statSync(filePath).isDirectory();
+        if (isDirectory) {
+            deleteEmptyFolders(filePath);
+        }
+    });
+    // Check if the directory is empty after deleting its subdirectories
+    const updatedFiles = fs.readdirSync(directory);
+    if (updatedFiles.length === 0) {
+        fs.rmdirSync(directory);
+        logger.debug({ label: `dedupeBundles`, message: `Deleted empty folder: ${directory}` });
+    }
+}
+//# sourceMappingURL=dedupe-bundles.js.map

package/build/es/transformers/mrt-static-uri-transformer.d.ts

@@ -0,0 +1,3 @@
+import type { UriTransformPlugin } from '@lwrjs/types';
+export default function mrtStaticUriTransformer(): UriTransformPlugin;
+//# sourceMappingURL=mrt-static-uri-transformer.d.ts.map

package/build/es/transformers/mrt-static-uri-transformer.js

@@ -0,0 +1,40 @@
+import { logger } from '@lwrjs/diagnostics';
+import { getMrtArtifactUrl } from '@lwrjs/shared-utils';
+export default function mrtStaticUriTransformer() {
+    return {
+        name: 'mrt-static-uri-transformer',
+        /**
+         * Transform to MRT Bundle URL
+         */
+        async transformUri(uriDef, _def, runtimeEnvironment) {
+            // If this is an asset and the ASSETS_ON_LAMBDA flag is set to true do not transform the URI
+            if (uriDef.artifactType === 'asset' && runtimeEnvironment?.featureFlags?.ASSETS_ON_LAMBDA) {
+                logger.debug({
+                    label: `${this.name}`,
+                    message: `uri not transformed ${uriDef.entry} -> ${uriDef.uri}`,
+                });
+                return {
+                    ...uriDef,
+                    external: false,
+                };
+            }
+            // Remove the basePath from the uri
+            let basePathlessUri = uriDef.uri;
+            if (runtimeEnvironment?.basePath && uriDef.uri.startsWith(runtimeEnvironment?.basePath)) {
+                basePathlessUri = uriDef.uri.replace(runtimeEnvironment?.basePath, '');
+            }
+            const uri = getMrtArtifactUrl(runtimeEnvironment?.basePath || '', basePathlessUri);
+            logger.debug({
+                label: `${this.name}`,
+                message: `normalized ${uriDef.artifactType} url ${uriDef.entry} -> ${uri}`,
+            });
+            return {
+                ...uriDef,
+                uri,
+                immutable: true,
+                external: true,
+            };
+        },
+    };
+}
+//# sourceMappingURL=mrt-static-uri-transformer.js.map

package/build/es/utils/decision-tree.d.ts

@@ -0,0 +1,35 @@
+import type { DecisionTree, I18NConfig, SiteArtifact } from '@lwrjs/types';
+export interface ArtifactVariantId {
+    specifier: string;
+    version?: string;
+    localeId?: string;
+    debug?: boolean;
+    ssr?: boolean;
+}
+export default class DecisionTreeImpl<Artifact extends SiteArtifact> implements DecisionTree<Artifact> {
+    private readonly root;
+    insert(siteArtifactId: string, artifact: Artifact, debug?: boolean, localeFallbacks?: Record<string, string[]>): void;
+    /**
+     * A method to handle deeper insertions, preserving the unique paths.
+     * This will be called for each node in the decision path.
+     */
+    private deepInsert;
+    find(siteArtifactId: string, debug?: boolean, ssr?: boolean, localeId?: string): Artifact | undefined;
+    /**
+     * Create a decision tree path to look up the most appropriate bundle
+     *
+     * @param specifier Bundle specifier
+     * @param version known version or will add the choice ''
+     * @param localeId preferred bundle locale or will add '' for default locale
+     * @param debug flag if debug bundle is preferred
+     * @param ssr flag if server bundle is requested
+     */
+    private createArtifactChoices;
+    /**
+     * Get the choices in a consistent order for possible choices or choices for lookup
+     */
+    private getOrderedChoices;
+    private createPossibleArtifactChoices;
+}
+export declare function createFallbackMap(config: I18NConfig): Record<string, string[]>;
+//# sourceMappingURL=decision-tree.d.ts.map