@lwrjs/shared-utils 0.9.0-alpha.8 → 0.9.0

package/build/cjs/site-metadata.cjs

@@ -0,0 +1,121 @@
+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/shared-utils/src/site-metadata.ts
+__markAsModule(exports);
+__export(exports, {
+  SiteMetadataImpl: () => SiteMetadataImpl
+});
+var import_path = __toModule(require("path"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_logger = __toModule(require("./logger.cjs"));
+var SITE_METADATA_PATH = ".metadata";
+var STATIC_BUNDLE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/bundle-metadata.json");
+var STATIC_RESOURCE_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/resource-metadata.json");
+var STATIC_ASSET_METADATA_PATH = import_path.default.join(SITE_METADATA_PATH, "/asset-metadata.json");
+var SiteMetadataImpl = class {
+  constructor(options) {
+    this.options = options;
+    this.siteBundles = this.readStaticBundleMetadata(options.rootDir);
+    this.siteResources = this.readStaticResourceMetadata(options.rootDir);
+    this.siteAssets = this.readStaticAssetsMetadata(options.rootDir);
+  }
+  getSiteRootDir() {
+    return this.options.rootDir;
+  }
+  getSiteBundles() {
+    return this.siteBundles;
+  }
+  getSiteResources() {
+    return this.siteResources;
+  }
+  getSiteAssets() {
+    return this.siteAssets;
+  }
+  async persistSiteMetadata() {
+    const siteMetadataPath = import_path.default.join(this.options.rootDir, SITE_METADATA_PATH);
+    try {
+      if (!await import_fs_extra.default.pathExists(siteMetadataPath)) {
+        await import_fs_extra.default.mkdir(siteMetadataPath, {recursive: true});
+      }
+      const bundleMetadataPath = import_path.default.join(this.options.rootDir, STATIC_BUNDLE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(bundleMetadataPath, this.siteBundles, {spaces: 2});
+      const resourceMetadataPath = import_path.default.join(this.options.rootDir, STATIC_RESOURCE_METADATA_PATH);
+      await import_fs_extra.default.writeJSON(resourceMetadataPath, this.siteResources, {spaces: 2});
+      const assetMetadataPath = import_path.default.join(this.options.rootDir, STATIC_ASSET_METADATA_PATH);
+      return import_fs_extra.default.writeJSON(assetMetadataPath, this.siteAssets, {spaces: 2});
+    } catch (err) {
+      console.error(`[SiteMetadata] Failed to save site metadata ${siteMetadataPath}`);
+      console.error(err);
+    }
+  }
+  readStaticBundleMetadata(staticRoot) {
+    let bundleMetadataPath;
+    let siteBundles = {bundles: {}};
+    try {
+      bundleMetadataPath = import_path.default.join(staticRoot, STATIC_BUNDLE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(bundleMetadataPath);
+      siteBundles = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Bundle Metadata: ${bundleMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteBundles;
+  }
+  readStaticResourceMetadata(staticRoot) {
+    let resourceMetadataPath;
+    let siteResources = {resources: {}};
+    try {
+      resourceMetadataPath = import_path.default.join(staticRoot, STATIC_RESOURCE_METADATA_PATH);
+      const savedMetadata = import_fs_extra.default.readJSONSync(resourceMetadataPath);
+      siteResources = savedMetadata;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${resourceMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteResources;
+  }
+  readStaticAssetsMetadata(staticRoot) {
+    let assetMetadataPath;
+    let siteAssets = {
+      assets: {}
+    };
+    try {
+      assetMetadataPath = import_path.default.join(staticRoot, STATIC_ASSET_METADATA_PATH);
+      siteAssets = import_fs_extra.default.readJSONSync(assetMetadataPath);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        import_logger.logger.debug(`[SiteMetadata] Failed to load Static Resource Metadata: ${assetMetadataPath}`);
+      } else {
+        throw error;
+      }
+    }
+    return siteAssets;
+  }
+};

package/build/es/compiler.d.ts

@@ -0,0 +1,15 @@
+import type { CompilerResult, LwrLockerConfig, ModuleCompiled } from '@lwrjs/types';
+/**
+ * When importing these modules make sure the optional dependencies are installed:
+ * - 'rollup' for convertToAmd()
+ * - '@locker/compiler' for lockerize()
+ */
+export declare const AMD_DEFINE = "LWR.define";
+export declare function convertToAmd(source: string, { id }: {
+    id: string;
+}, forceNamedExports?: boolean): Promise<CompilerResult>;
+/** Locker
+ * Trusted Components can contain namespaces with wildcard or single component
+ */
+export declare function lockerize({ compiledSource: source, specifier, moduleEntry: { entry: filename } }: ModuleCompiled, { trustedComponents }: LwrLockerConfig, sourcemap?: boolean): CompilerResult;
+//# sourceMappingURL=compiler.d.ts.map

package/build/es/compiler.js

@@ -0,0 +1,65 @@
+import { explodeSpecifier } from './identity.js';
+import { Compiler as Locker } from '@locker/compiler';
+import { rollup } from 'rollup';
+/**
+ * When importing these modules make sure the optional dependencies are installed:
+ * - 'rollup' for convertToAmd()
+ * - '@locker/compiler' for lockerize()
+ */
+export const AMD_DEFINE = 'LWR.define';
+const AMD_ROLLUP_PLUGIN = function (rootId, source) {
+    return {
+        name: 'lwr-amd-inline',
+        resolveId(id) {
+            return rootId === id ? id : undefined;
+        },
+        load(id) {
+            return rootId === id ? source : undefined;
+        },
+    };
+};
+export async function convertToAmd(source, { id }, forceNamedExports = true) {
+    const bundler = await rollup({
+        input: id,
+        plugins: [AMD_ROLLUP_PLUGIN(id, source)],
+        onwarn(warning, warn) {
+            // do not print out these: 'a' is imported by b, but could not be resolved – treating it as an external dependency
+            if (warning.code === 'UNRESOLVED_IMPORT')
+                return;
+            warn(warning);
+        },
+    });
+    const { output } = await bundler.generate({
+        amd: { id, define: AMD_DEFINE },
+        exports: forceNamedExports ? 'named' : 'auto',
+        format: 'amd',
+    });
+    const { code } = output[0];
+    return { code, map: null };
+}
+/** Locker
+ * Trusted Components can contain namespaces with wildcard or single component
+ */
+export function lockerize({ compiledSource: source, specifier, moduleEntry: { entry: filename } }, { trustedComponents }, sourcemap = false) {
+    const { namespace, name: rawName } = explodeSpecifier(specifier);
+    const [name] = rawName.split('#');
+    const bareSpecifier = namespace ? `${namespace}/${name}` : name;
+    const isJS = filename.endsWith('.js') || filename.endsWith('.mjs') || filename.endsWith('.ts');
+    // lockerize if component is JS and is not explicitly trusted or in a trusted namespace
+    if (isJS &&
+        trustedComponents &&
+        !trustedComponents.includes(`${namespace}/*`) &&
+        !trustedComponents.includes(bareSpecifier)) {
+        const { code } = Locker.compile(source, {
+            componentName: name,
+            filename,
+            // put non-namespaced modules in a single sandbox - this should only be non-lwc npm modules
+            sandboxKey: namespace || 'sandbox',
+            sourcemap,
+            remapDynamicImport: true, // support for dynamic imports
+        });
+        return { code, map: null };
+    }
+    return { code: source, map: null };
+}
+//# sourceMappingURL=compiler.js.map

package/build/es/env.d.ts

@@ -1,3 +1,3 @@
-import { FeatureFlags } from '@lwrjs/types';
+import type { FeatureFlags } from '@lwrjs/types';
 export declare function getFeatureFlags(): FeatureFlags;
 //# sourceMappingURL=env.d.ts.map

package/build/es/env.js

@@ -1,17 +1,25 @@
 export function getFeatureFlags() {
-    let legacyLoader = process.env.LEGACY_LOADER !== undefined && process.env.LEGACY_LOADER === 'true' ? true : false;
-    try {
-        // Use the Shim for MRT since we don't have access to managing environment variables
-        if (LWR) {
-            legacyLoader = LWR.LEGACY_LOADER;
-        }
-    }
-    catch (e) {
-        // No shim, ignore error
-    }
+    // Add any new feature flags here to parse from environment variables
     return {
         // DEFAULT LEGACY_LOADER = false;
-        LEGACY_LOADER: legacyLoader,
+        LEGACY_LOADER: process.env.LEGACY_LOADER !== undefined && process.env.LEGACY_LOADER.toLowerCase() === 'true'
+            ? true
+            : false,
+        // SSR should concatenate bundles, default = false
+        SSR_STATIC_BUNDLES: process.env.SSR_STATIC_BUNDLES !== undefined &&
+            process.env.SSR_STATIC_BUNDLES.toLowerCase() === 'true'
+            ? true
+            : false,
+        // Should we use a js worker for SSR, sand-boxing = false (use locker for ssr sand-boxing)
+        SSR_SANDBOX_WORKER: process.env.SSR_SANDBOX_WORKER !== undefined &&
+            process.env.SSR_SANDBOX_WORKER.toLowerCase() === 'true'
+            ? true
+            : false,
+        // Should we load load the assets from the lambda on MRT
+        ASSETS_ON_LAMBDA: process.env.ASSETS_ON_LAMBDA !== undefined &&
+            process.env.ASSETS_ON_LAMBDA.toLowerCase() === 'true'
+            ? true
+            : false,
     };
 }
 //# sourceMappingURL=env.js.map

package/build/es/fs-watch.d.ts

@@ -0,0 +1,17 @@
+import type { Watcher, WatcherFactory, WatchOptions } from '@lwrjs/types';
+/**
+ * Factory comptable with the LWR Runtime to create a file watch library for LWR dev server.
+ * When importing this module make sure the optional library 'chokidar' is installed.
+ */
+export declare class WatcherFactoryImpl implements WatcherFactory {
+    /**
+     * Set up a watcher with the given options
+     * @param options
+     */
+    createFileWatcher(options?: WatchOptions): Watcher;
+    /**
+     * Set up file watcher
+     */
+    setupWatcher(onModuleChange: Function): Watcher;
+}
+//# sourceMappingURL=fs-watch.d.ts.map

package/build/es/fs-watch.js

@@ -0,0 +1,27 @@
+import chokidar from 'chokidar';
+import { debounce } from './object.js';
+import { logger } from './logger.js';
+/**
+ * Factory comptable with the LWR Runtime to create a file watch library for LWR dev server.
+ * When importing this module make sure the optional library 'chokidar' is installed.
+ */
+export class WatcherFactoryImpl {
+    /**
+     * Set up a watcher with the given options
+     * @param options
+     */
+    createFileWatcher(options = { persistent: true, ignored: '**/node_modules/**' }) {
+        return chokidar.watch([], options);
+    }
+    /**
+     * Set up file watcher
+     */
+    setupWatcher(onModuleChange) {
+        const fileWatcher = this.createFileWatcher();
+        fileWatcher.on('change', debounce((file) => onModuleChange(file), 500));
+        fileWatcher.on('unlink', debounce((file) => onModuleChange(file), 500));
+        fileWatcher.on('add', (file) => logger.info(`Watching: ${file}`));
+        return fileWatcher;
+    }
+}
+//# sourceMappingURL=fs-watch.js.map

package/build/es/fs.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { ResourcePaths, Watcher, ViewSource } from '@lwrjs/types';
+import type { AssetIdentifier, ResourcePaths, ViewSource } from '@lwrjs/types';
 import { lookup } from 'mime-types';
 /**
  * Create a hash string for a source
@@ -16,15 +16,6 @@ export declare function readFile(filePath: string): string;
  * @param filePath
  */
 export declare function resolveFileExtension(filePath: string): string;
-/**
- * Set up a watcher with the given options
- * @param options
- */
-export declare function createFileWatcher(options?: any): Watcher;
-/**
- * Set up file watcher
- */
-export declare function setupWatcher(onModuleChange: Function): Watcher;
 /**
  * Returns if view of specific type can be resolved
  *
@@ -41,4 +32,8 @@ export declare function getViewSourceFromFile(source: string): ViewSource;
 export declare function normalizeDirectory(dir: string, rootDir: string): string;
 export declare function normalizeResourcePath(rawPath: string, { rootDir, assets, contentDir, layoutsDir }: ResourcePaths, allowUnresolvedAlias?: boolean): string;
 export { lookup as mimeLookup };
+/**
+ * Tries to convert any URL or $aliased path into a canonical fs path
+ */
+export declare function normalizeAssetSpecifier(assetId: AssetIdentifier, assetPathMap: Map<string, string>, resourcePaths: ResourcePaths, basePath: string): string;
 //# sourceMappingURL=fs.d.ts.map

package/build/es/fs.js

@@ -2,8 +2,6 @@ import fs from 'fs';
 import pathLib from 'path';
 import crypto from 'crypto';
 import { slugify } from './identity.js';
-import { debounce } from './object.js';
-import chokidar from 'chokidar';
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { lookup } from 'mime-types';
 import { DEBUG, logger, VERBOSE } from './logger.js';
@@ -38,10 +36,10 @@ export function resolveFileExtension(filePath) {
     // No extension, if it exist, it can be a dir or a file
     if (fs.existsSync(filePath)) {
         if (fs.statSync(filePath).isFile()) {
-            return filePath; // extensionless file, which is odd but...
+            return filePath; // extension-less file, which is odd but...
         }
         else {
-            filePath = pathLib.join(filePath, 'index'); // if is a dir we will be tesing the extensions
+            filePath = pathLib.join(filePath, 'index'); // if is a dir we will be testing the extensions
         }
     }
     // At this point we have a file with no extension so we try for the default (js,ts) or fail
@@ -55,25 +53,6 @@ export function resolveFileExtension(filePath) {
         throw new Error(`Unable to find file "${filePath}"`);
     }
 }
-/**
- * Set up a watcher with the given options
- * @param options
- */
-export function createFileWatcher(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options = { persistent: true, ignored: '**/node_modules/**' }) {
-    return chokidar.watch([], options);
-}
-/**
- * Set up file watcher
- */
-export function setupWatcher(onModuleChange) {
-    const fileWatcher = createFileWatcher();
-    fileWatcher.on('change', debounce((file) => onModuleChange(file), 500));
-    fileWatcher.on('unlink', debounce((file) => onModuleChange(file), 500));
-    fileWatcher.on('add', (file) => logger.info(`Watching: ${file}`));
-    return fileWatcher;
-}
 /**
  * Returns if view of specific type can be resolved
  *
@@ -153,4 +132,35 @@ function logMetrics(filePath) {
         }
     }
 }
+/**
+ * Tries to convert any URL or $aliased path into a canonical fs path
+ */
+export function normalizeAssetSpecifier(assetId, assetPathMap, resourcePaths, basePath) {
+    const { specifier, importer, type } = assetId;
+    if (specifier.startsWith('./') || specifier.startsWith('../')) {
+        if (!importer) {
+            throw Error(`Unable to resolve relative import "${specifier}" without an importer.`);
+        }
+        return pathLib.join(pathLib.dirname(importer), specifier);
+    }
+    if (type === 'content-asset') {
+        const originSpecifier = !basePath ? specifier : specifier.split(basePath)[1];
+        return pathLib.join(resourcePaths.contentDir, originSpecifier);
+    }
+    if (specifier[0] === '$') {
+        // This is a fs path containing an asset alias
+        return normalizeResourcePath(specifier, resourcePaths);
+    }
+    // This is an absolute path to the server
+    // Match in 2 ways:
+    //      - Directories: the prefix of the asset specifier/path matches a configured assets[i].urlPath
+    //      - Individual files: the asset specifier is equal to a configured assets[i].urlPath
+    for (const [urlPath, fsPath] of assetPathMap.entries()) {
+        const slashPath = urlPath.endsWith('/') ? urlPath : `${urlPath}/`;
+        if (specifier.startsWith(slashPath) || specifier === urlPath) {
+            return specifier.replace(urlPath, fsPath);
+        }
+    }
+    return specifier;
+}
 //# sourceMappingURL=fs.js.map

package/build/es/graph.d.ts

@@ -1,9 +1,10 @@
-import { ModuleRegistry, RuntimeEnvironment, RuntimeParams, FlattenedModuleGraphs, GraphNode, GraphOptions, ModuleBundler } from '@lwrjs/types';
+import type { ModuleRegistry, RuntimeEnvironment, RuntimeParams, FlattenedModuleGraphs, GraphNode, GraphOptions, ModuleBundler, PublicModuleRegistry, PublicModuleBundler } from '@lwrjs/types';
 export declare enum GraphDepth {
     ALL = "all",
     DIRECT = "direct",
     NONE = "none"
 }
+export declare function isBundler(registry: PublicModuleRegistry | PublicModuleBundler): registry is PublicModuleBundler;
 export declare function getModuleGraphs(specifier: string, // version | un-versioned specifiers
 options: GraphOptions, moduleRegistry: ModuleRegistry, defRegistry: ModuleRegistry | ModuleBundler, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, visited?: Map<string, GraphNode>): Promise<FlattenedModuleGraphs>;
 //# sourceMappingURL=graph.d.ts.map

package/build/es/graph.js

@@ -8,7 +8,7 @@ export var GraphDepth;
     GraphDepth["NONE"] = "none";
 })(GraphDepth || (GraphDepth = {}));
 // type guard for ViewDef responses
-function isBundler(registry) {
+export function isBundler(registry) {
     return registry.getModuleBundle !== undefined;
 }
 async function traverse(module, depth, flattened, 
@@ -94,7 +94,7 @@ defRegistry, runtimeEnvironment, runtimeParams) {
 }
 async function flatten(versionedSpecifier, flattened, idx, visited) {
     const node = visited.get(versionedSpecifier);
-    if (node) {
+    if (flattened[idx]?.static && node?.static) {
         node.static.forEach(async (imp) => {
             if (!flattened[idx].static.includes(imp)) {
                 flattened[idx].static.push(imp);
@@ -129,7 +129,7 @@ options, moduleRegistry, defRegistry, runtimeEnvironment, runtimeParams, visited
             // eslint-disable-next-line no-await-in-loop
             const moduleId = await getVersionedModuleId(visitedSpecifier, moduleRegistry);
             // eslint-disable-next-line no-await-in-loop
-            const uri = await moduleRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
+            const uri = await defRegistry.resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams);
             uriMap[visitedSpecifier] = uri;
         }
     }

package/build/es/identity.d.ts

@@ -1,5 +1,5 @@
 import getCacheKeyFromJson from 'fast-json-stable-stringify';
-import { AbstractModuleId, AssetIdentity, BundleDefinition, MappingIdentity, MiddlewareRequest, ModuleDefinition, ModuleId, ModuleIdentity, NormalizedLwrAppBootstrapConfig, PublicModuleRegistry, ResourceIdentity, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import { AbstractModuleId, AssetSource, BundleDefinition, ModuleDefinition, NormalizedLwrAppBootstrapConfig, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 export declare const VERSION_SIGIL = "/v/";
 export declare const LOCALE_SIGIL = "l";
 export declare const ENVIRONMENT_SIGIL = "e";
@@ -8,6 +8,7 @@ export declare const LATEST_SIGNATURE = "latest";
 export declare const DEFAULT_TITLE = "LWR App";
 export declare const IMMUTABLE_ASSET_PREFIX = "/_immutable/";
 export declare const ASSETS_CACHE_DIR = "assetsCache";
+export declare const VERSION_NOT_PROVIDED = "version-not-provided";
 export declare const DEFAULT_LOCKER_TRUSTED_CMP: string[];
 export declare const DEFAULT_LWR_LOCKER_CONFIG: {
     enabled: boolean;
@@ -57,29 +58,9 @@ export declare function explodeSpecifiers(rawSpecifiers: string): PartialModuleI
  * @example - { namespace: '@salesforce', name: 'label/my.label', version: '1' } => '@salesforce/label/my.label/v/1'
  */
 export declare function getSpecifier({ specifier, namespace, name, version }: ModuleIdentifierPartial): string;
-/**
- * Create a versioned specifier based on the module registry
- *
- * @remarks
- * If the incoming specifier is already versioned, it will be returned as is.
- *
- * The returned specifier's version conforms to the format expected to be used
- * external to the framework (e.g. via the identity in the URL, mapping metadata,
- * AMD define module name). This format conforms to the `normalizeVersionToUri`
- * implementation (e.g. version semver format -- major_minor_patch).
- *
- * This method is analogous to `getSpecifier` but supports non-versioned `rawSpecifiers`
- * The inverse of this method is `explodeSpecifier`
-
- * @param specifier - the module specifier
- * @param moduleRegistry - the public module registry
- *
- * @returns the specifier for the latest version
- *
- * @example - 'c/form' => 'c/form/v/0_0_1'
- * @example - 'c/form/v/0.0.2' => 'c/form/v/0_0_2'
- */
-export declare function getVersionedSpecifier(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<string>;
+interface VersionedAbstractModuleId extends AbstractModuleId {
+    version: string;
+}
 /**
  * Create a AbstractModuleId using the module registry to resolve the version
  * if a version is not provided in the `rawSpecifier`
@@ -100,7 +81,7 @@ export declare function getVersionedSpecifier(rawSpecifier: string, moduleRegist
  * @example - 'c/form/v/0.0.2' => {specifier: "c/form", version: "0.0.2"}
  * @example - 'c/form/v/0_0_2' => {specifier: "c/form", version: "0.0.2"}
  */
-export declare function getVersionedModuleId(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<Required<Pick<ModuleId, 'specifier' | 'version'>>>;
+export declare function getVersionedModuleId(rawSpecifier: string, moduleRegistry: PublicModuleRegistry): Promise<VersionedAbstractModuleId>;
 interface PackageIdentity {
     scope?: string;
     packageName: string;
@@ -124,9 +105,9 @@ export declare function parsePackageSpecifier(specifier: string): PackageIdentit
  * @param name A string in kebab case
  * @example - 'name-of-something' => 'name/ofSomething'
  */
-export declare function kebabCaseToModuleSpecifer(name: string): string;
+export declare function kebabCaseToModuleSpecifier(name: string): string;
 /**
- * Clone of lwr/init, reverse of kebabCaseToModuleSpecifer, strips off versions
+ * Clone of lwr/init, reverse of kebabCaseToModuleSpecifier, strips off versions
  * @param specifier
  * @example - 'name/ofSomething/v/1.0.0' => 'name-of-something'
  */
@@ -157,9 +138,6 @@ export declare function getModuleUriPrefix({ apiVersion, bundle, format, compat,
 export declare function getMappingUriPrefix({ apiVersion, bundle, format, compat, basePath }: RuntimeEnvironment, { locale, environment }?: RuntimeParams): string;
 export { getCacheKeyFromJson };
 export declare function isExternalUrl(url: string): boolean;
+export declare function isAssetSourceExternal(assetSource: AssetSource): boolean;
 export declare function isBundleDefinition(definition: ModuleDefinition | BundleDefinition): definition is BundleDefinition;
-export declare function getModuleIdentity(req: MiddlewareRequest): ModuleIdentity;
-export declare function getMappingIdentity(req: MiddlewareRequest): MappingIdentity;
-export declare function getResourceIdentity(req: MiddlewareRequest): ResourceIdentity;
-export declare function getAssetIdentity(req: MiddlewareRequest): AssetIdentity;
 //# sourceMappingURL=identity.d.ts.map