@lwrjs/fs-asset-provider 0.9.9-alpha.8 → 0.10.0-alpha.0

package/build/cjs/index.cjs

@@ -29,22 +29,30 @@ __export(exports, {
 var import_fs = __toModule(require("fs"));
 var import_path = __toModule(require("path"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_shared_utils2 = __toModule(require("@lwrjs/shared-utils"));
 function hash(filePath) {
   const result = import_fs.default.statSync(filePath);
   return (result.mtimeMs * 1e4).toString();
 }
 var FsAssetProvider = class {
-  constructor(pluginConfig, providerConfig) {
+  constructor(_pluginConfig, providerConfig) {
     this.name = "fs-asset-provider";
     this.cachedAssets = new Map();
     const {
       appEmitter,
-      runtimeEnvironment: {watchFiles}
+      runtimeEnvironment: {watchFiles},
+      watcherFactory
     } = providerConfig;
+    const {assets, rootDir, layoutsDir, contentDir, basePath} = providerConfig.config;
+    this.basePath = basePath;
+    this.resourcePaths = {assets, rootDir, layoutsDir, contentDir};
+    this.assetPathMap = assets.reduce((map, asset) => {
+      const urlPath = `${basePath}${asset.urlPath}`;
+      map.set(urlPath, asset.dir || asset.file);
+      return map;
+    }, new Map());
     this.emitter = appEmitter;
-    if (watchFiles) {
-      this.watcher = (0, import_shared_utils2.setupWatcher)(this.onModuleChange.bind(this));
+    if (watchFiles && watcherFactory) {
+      this.watcher = watcherFactory.setupWatcher(this.onModuleChange.bind(this));
     }
   }
   async onModuleChange(fileChanged) {
@@ -53,34 +61,40 @@ var FsAssetProvider = class {
       throw new Error("We are observing a file we have not yet processed, this shouldn't happen...");
     }
     this.cachedAssets.delete(fileChanged);
-    cachedAsset = await this.getAsset(fileChanged);
+    cachedAsset = await this.getAssetFromFSPath(fileChanged);
     this.emitter.notifyAssetSourceChanged(cachedAsset);
   }
   async initialize() {
     return;
   }
-  async getAsset(fullAssetPath) {
-    fullAssetPath = decodeURI(fullAssetPath);
+  async getAsset(assetId) {
+    const fullAssetPath = (0, import_shared_utils.normalizeAssetSpecifier)(assetId, this.assetPathMap, this.resourcePaths, this.basePath);
+    return this.getAssetFromFSPath(fullAssetPath);
+  }
+  async getAssetFromFSPath(assetPath) {
+    const fullAssetPath = decodeURI(assetPath);
     if (!this.cachedAssets.has(fullAssetPath)) {
-      const [assetPath] = fullAssetPath.split("?");
-      const ext = (0, import_path.extname)(`x.${assetPath}`).toLowerCase().substr(1);
-      if (ext && import_fs.default.existsSync(assetPath)) {
-        const ownHash = hash(assetPath);
-        const mimeType = (0, import_shared_utils.mimeLookup)(assetPath);
+      const [assetPath2] = fullAssetPath.split("?");
+      const ext = (0, import_path.extname)(`x.${assetPath2}`).toLowerCase().substring(1);
+      if (ext && import_fs.default.existsSync(assetPath2)) {
+        const ownHash = hash(assetPath2);
+        const mimeType = (0, import_shared_utils.mimeLookup)(assetPath2);
         const assetDef = {
-          entry: assetPath,
+          entry: assetPath2,
           ext,
           mime: mimeType,
           ownHash,
           content: (passedEncoding) => {
             const encoding = passedEncoding || (mimeType && mimeType.startsWith("text/") ? "utf-8" : null);
-            return import_fs.default.readFileSync(assetPath, {encoding});
+            return import_fs.default.readFileSync(assetPath2, {encoding});
           }
         };
         this.cachedAssets.set(fullAssetPath, assetDef);
         if (this.watcher) {
-          this.watcher.add(assetPath);
+          this.watcher.add(assetPath2);
         }
+      } else {
+        return void 0;
       }
     }
     return this.cachedAssets.get(fullAssetPath);

package/build/es/index.d.ts

@@ -1,12 +1,22 @@
-import { ProviderContext, AssetProvider, AssetSource, Watcher, LwrAppEmitter } from '@lwrjs/types';
+import type { ProviderContext, AssetProvider, AssetSource, Watcher, LwrAppEmitter, AssetIdentifier, ResourcePaths } from '@lwrjs/types';
 export default class FsAssetProvider implements AssetProvider {
     name: string;
     emitter: LwrAppEmitter;
     watcher?: Watcher;
     cachedAssets: Map<string, AssetSource>;
-    constructor(pluginConfig: unknown, providerConfig: ProviderContext);
+    resourcePaths: ResourcePaths;
+    assetPathMap: Map<string, string>;
+    basePath: string;
+    constructor(_pluginConfig: unknown, providerConfig: ProviderContext);
     onModuleChange(fileChanged: string): Promise<void>;
     initialize(): Promise<void>;
-    getAsset(fullAssetPath: string): Promise<AssetSource | undefined>;
+    /**
+     * Public API to get an AssetSource object from an asset identifier
+     */
+    getAsset(assetId: AssetIdentifier): Promise<AssetSource | undefined>;
+    /**
+     * Get and AssetSource object from a resolved filesystem file path.
+     */
+    private getAssetFromFSPath;
 }
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,19 +1,26 @@
 import fs from 'fs';
 import { extname } from 'path';
-import { mimeLookup } from '@lwrjs/shared-utils';
-import { setupWatcher } from '@lwrjs/shared-utils';
+import { mimeLookup, normalizeAssetSpecifier } from '@lwrjs/shared-utils';
 function hash(filePath) {
     const result = fs.statSync(filePath);
     return (result.mtimeMs * 10000).toString();
 }
 export default class FsAssetProvider {
-    constructor(pluginConfig, providerConfig) {
+    constructor(_pluginConfig, providerConfig) {
         this.name = 'fs-asset-provider';
         this.cachedAssets = new Map();
-        const { appEmitter, runtimeEnvironment: { watchFiles }, } = providerConfig;
+        const { appEmitter, runtimeEnvironment: { watchFiles }, watcherFactory, } = providerConfig;
+        const { assets, rootDir, layoutsDir, contentDir, basePath } = providerConfig.config;
+        this.basePath = basePath;
+        this.resourcePaths = { assets, rootDir, layoutsDir, contentDir };
+        this.assetPathMap = assets.reduce((map, asset) => {
+            const urlPath = `${basePath}${asset.urlPath}`;
+            map.set(urlPath, asset.dir || asset.file);
+            return map;
+        }, new Map());
         this.emitter = appEmitter;
-        if (watchFiles) {
-            this.watcher = setupWatcher(this.onModuleChange.bind(this));
+        if (watchFiles && watcherFactory) {
+            this.watcher = watcherFactory.setupWatcher(this.onModuleChange.bind(this));
         }
     }
     async onModuleChange(fileChanged) {
@@ -23,19 +30,29 @@ export default class FsAssetProvider {
         }
         // Update the cache entry
         this.cachedAssets.delete(fileChanged);
-        cachedAsset = await this.getAsset(fileChanged);
+        cachedAsset = await this.getAssetFromFSPath(fileChanged);
         this.emitter.notifyAssetSourceChanged(cachedAsset);
     }
     // -- Public API --------------------------------------------------------------------
     async initialize() {
         return;
     }
-    async getAsset(fullAssetPath) {
-        fullAssetPath = decodeURI(fullAssetPath); // decodeURIComponent decodes too many things (eg: /)
+    /**
+     * Public API to get an AssetSource object from an asset identifier
+     */
+    async getAsset(assetId) {
+        const fullAssetPath = normalizeAssetSpecifier(assetId, this.assetPathMap, this.resourcePaths, this.basePath);
+        return this.getAssetFromFSPath(fullAssetPath);
+    }
+    /**
+     * Get and AssetSource object from a resolved filesystem file path.
+     */
+    async getAssetFromFSPath(assetPath) {
+        const fullAssetPath = decodeURI(assetPath); // decodeURIComponent decodes too many things (eg: /)
         if (!this.cachedAssets.has(fullAssetPath)) {
             const [assetPath] = fullAssetPath.split('?'); // remove query params
             // Clever normalization to avoid corner cases
-            const ext = extname(`x.${assetPath}`).toLowerCase().substr(1);
+            const ext = extname(`x.${assetPath}`).toLowerCase().substring(1);
             if (ext && fs.existsSync(assetPath)) {
                 const ownHash = hash(assetPath);
                 const mimeType = mimeLookup(assetPath);
@@ -55,6 +72,10 @@ export default class FsAssetProvider {
                     this.watcher.add(assetPath);
                 }
             }
+            else {
+                // returned undefined move on to next provider
+                return undefined;
+            }
         }
         return this.cachedAssets.get(fullAssetPath);
     }

package/package.json

@@ -4,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.9-alpha.8",
+    "version": "0.10.0-alpha.0",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/fs-asset-provider"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -30,13 +30,13 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/shared-utils": "0.9.9-alpha.8"
+        "@lwrjs/shared-utils": "0.10.0-alpha.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.9-alpha.8"
+        "@lwrjs/types": "0.10.0-alpha.0"
     },
     "engines": {
-        "node": ">=14.15.4 <19"
+        "node": ">=16.0.0 <20"
     },
-    "gitHead": "ac15f9c862f53f0fab34ea229c8c27b1d66c9f7e"
+    "gitHead": "ab31238f802c9c757c5f5c08e5d89e66887fc5af"
 }