@komaci/prefetch 242.1.9 → 242.2.1

package/build/__mocks__/@lwrjs/router.js

@@ -0,0 +1,8 @@
+export const createRouter = jest.fn().mockImplementation((config) => {
+    return {
+        config,
+        subscribe: jest.fn(),
+        navigate: jest.fn(),
+    };
+});
+//# sourceMappingURL=router.js.map

package/build/__mocks__/lwr/router.js

@@ -0,0 +1,8 @@
+export const createRouter = jest.fn().mockImplementation((config) => {
+    return {
+        config,
+        subscribe: jest.fn(),
+        navigate: jest.fn(),
+    };
+});
+//# sourceMappingURL=router.js.map

package/build/__mocks__/mockAdgModule.d.ts

@@ -1,3 +1,3 @@
-declare const _default: import("packages/@komaci/resolver/src/modules/komaci/resolverTypes/resolverTypes").AdgModuleHandle | undefined;
+declare const _default: import("komaci/resolverTypes").AdgModuleHandle | undefined;
 export default _default;
 //# sourceMappingURL=mockAdgModule.d.ts.map

package/build/__mocks__/mockAdgModule.js

@@ -0,0 +1,11 @@
+import registerAdgFunction from 'komaci/registerAdgFunction';
+const emptyAdg = {
+    parentClass: undefined,
+    properties: {},
+    functions: [],
+    composition: () => [],
+};
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const adgFunction = (fct) => emptyAdg;
+export default registerAdgFunction(adgFunction);
+//# sourceMappingURL=mockAdgModule.js.map

package/build/__mocks__/o11y/client.js

@@ -0,0 +1,15 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const mockInstrumentObj = {
+    log: jest.fn(),
+    error: jest.fn(),
+    trackValue: jest.fn(),
+    startActivity: jest.fn().mockImplementation((name) => ({
+        stop: jest.fn(),
+        error: jest.fn(),
+    })),
+    incrementCounter: jest.fn(),
+};
+export const getInstrumentation = jest
+    .fn()
+    .mockImplementation((name) => mockInstrumentObj);
+//# sourceMappingURL=client.js.map

package/build/__mocks__/o11y_schema/sf_komaci.js

@@ -0,0 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const wireContextSchema = {};
+export const batchSchema = {};
+export const bulkResolveSchema = {};
+export const prefetchSchema = {};
+//# sourceMappingURL=sf_komaci.js.map

package/build/modules/komaci/prefetch/prefetch.js

@@ -4,51 +4,51 @@ import { createRouter } from 'lwr/router';
 // NOTE: Backward compatible prefetch until primer is updated to handle this.
 // TODO W-9690128 - Let's potentially remove this prefetch method and update lsdk code to call `getPrefetchState` directly.
 export function prefetch(routes = [], pageReferences = [], config) {
-  if (!routes?.length || !pageReferences?.length) {
-    return Promise.resolve([]);
-  }
-
-  const router = createRouter({
-    routes
-  });
-  return new Promise((resolve, reject) => {
-    let currentState;
-    const addressesProcessed = [];
-    const wrappedConfig = {
-      maxConcurrent: config?.maxConcurrent,
-      onAddressProcessed: status => {
-        addressesProcessed.push(status);
-        if (config && config.onAddressProcessed) config.onAddressProcessed(status);
-      },
-      onStateChanged: status => {
-        const {
-          state
-        } = status;
-
-        if (state === 'running') {
-          if (!currentState) {
-            currentState = state;
-          } else {
-            reject(new Error(`Unexpected state transition. ${currentState} -> ${state}`));
-          }
-        } else if (state === 'done') {
-          if (addressesProcessed.length !== pageReferences.length) {
-            reject(new Error(`Prefetch error, expected ${pageReferences.length} addresses processed, but only got ${addressesProcessed.length}`));
-          }
-
-          resolve(addressesProcessed);
-        } else if (state === 'error') {
-          reject(new Error(`Prefetch error: ${status.message}`));
-        }
-
-        if (config && config.onStateChanged) config.onStateChanged(status);
-      },
-      instrumentationContext: config?.instrumentationContext,
-      downloadImage: config?.downloadImage
-    };
-    getPrefetchService(router, pageReferences, wrappedConfig);
-  });
+    if (!(routes === null || routes === void 0 ? void 0 : routes.length) || !(pageReferences === null || pageReferences === void 0 ? void 0 : pageReferences.length)) {
+        return Promise.resolve([]);
+    }
+    const router = createRouter({
+        routes,
+    });
+    return new Promise((resolve, reject) => {
+        let currentState;
+        const addressesProcessed = [];
+        const wrappedConfig = {
+            maxConcurrent: config === null || config === void 0 ? void 0 : config.maxConcurrent,
+            onAddressProcessed: (status) => {
+                addressesProcessed.push(status);
+                if (config && config.onAddressProcessed)
+                    config.onAddressProcessed(status);
+            },
+            onStateChanged: (status) => {
+                const { state } = status;
+                if (state === 'running') {
+                    if (!currentState) {
+                        currentState = state;
+                    }
+                    else {
+                        reject(new Error(`Unexpected state transition. ${currentState} -> ${state}`));
+                    }
+                }
+                else if (state === 'done') {
+                    if (addressesProcessed.length !== pageReferences.length) {
+                        reject(new Error(`Prefetch error, expected ${pageReferences.length} addresses processed, but only got ${addressesProcessed.length}`));
+                    }
+                    resolve(addressesProcessed);
+                }
+                else if (state === 'error') {
+                    reject(new Error(`Prefetch error: ${status.message}`));
+                }
+                if (config && config.onStateChanged)
+                    config.onStateChanged(status);
+            },
+            instrumentationContext: config === null || config === void 0 ? void 0 : config.instrumentationContext,
+            downloadImage: config === null || config === void 0 ? void 0 : config.downloadImage,
+        };
+        getPrefetchService(router, pageReferences, wrappedConfig);
+    });
 }
 export function getPrefetchService(router, addresses, config) {
-  return new PrefetchService(router, addresses, config);
-}
+    return new PrefetchService(router, addresses, config);
+}
+//# sourceMappingURL=prefetch.js.map

package/build/modules/komaci/prefetchService/prefetchService.js

@@ -1,509 +1,443 @@
-import { ERROR_PREFIX, PrefetchStatusStates as STATE } from 'komaci/prefetchTypes';
+import { ERROR_PREFIX, PrefetchStatusStates as STATE, } from 'komaci/prefetchTypes';
 import { getInstrumentation } from 'o11y/client';
 import { getBulkAdgResolver } from 'komaci/resolver';
 import { InstrumentedAction } from 'komaci/instrumentedAction';
-import { bulkResolveSchema, prefetchSchema, prefetchServiceSchema, totalRoutingSchema } from 'o11y_schema/sf_komaci';
+import { bulkResolveSchema, prefetchSchema, prefetchServiceSchema, totalRoutingSchema, } from 'o11y_schema/sf_komaci';
 const NO_ADG_MODULE_FOUND = 'No ADG module found for given address.';
 const ValidStatusTransitions = {
-  [STATE.init]: [STATE.running, STATE.stopped, STATE.error],
-  [STATE.running]: [STATE.done, STATE.error, STATE.stopped],
-  [STATE.error]: [STATE.stopped, STATE.done],
-  [STATE.done]: [STATE.stopped],
-  [STATE.stopped]: [],
-
-  isValid(oldState, newState) {
-    return this[oldState].includes(newState);
-  }
-
+    [STATE.init]: [STATE.running, STATE.stopped, STATE.error],
+    [STATE.running]: [STATE.done, STATE.error, STATE.stopped],
+    [STATE.error]: [STATE.stopped, STATE.done],
+    [STATE.done]: [STATE.stopped],
+    [STATE.stopped]: [],
+    isValid(oldState, newState) {
+        return this[oldState].includes(newState);
+    },
 };
 export class PrefetchService {
-  config = {};
-  state = STATE.init;
-  apiOptions = {};
-
-  constructor(router, addresses, config = {}) {
-    if (!router) {
-      throw new TypeError(`${ERROR_PREFIX} Must provide Router.`);
+    constructor(router, addresses, config = {}) {
+        this.config = {};
+        this.state = STATE.init;
+        this.apiOptions = {};
+        if (!router) {
+            throw new TypeError(`${ERROR_PREFIX} Must provide Router.`);
+        }
+        this.config = config;
+        this.apiOptions.instrumentationContext = this.config.instrumentationContext
+            ? this.config.instrumentationContext
+            : undefined;
+        this.router = router;
+        this.adgMap = new Map();
+        this.resolutionGroups = [];
+        this._instrumentation = getInstrumentation('komaci');
+        this._activity = this._instrumentation.startActivity('prefetch', this.apiOptions);
+        this._size = addresses.length;
+        //FIXME: to use o11y.startActivity() when o11y available
+        this._startTime = Date.now();
+        this.prefetch(addresses);
     }
-
-    this.config = config;
-    this.apiOptions.instrumentationContext = this.config.instrumentationContext ? this.config.instrumentationContext : undefined;
-    this.router = router;
-    this.adgMap = new Map();
-    this.resolutionGroups = [];
-    this._instrumentation = getInstrumentation('komaci');
-    this._activity = this._instrumentation.startActivity('prefetch', this.apiOptions);
-    this._size = addresses.length; //FIXME: to use o11y.startActivity() when o11y available
-
-    this._startTime = Date.now();
-    this.prefetch(addresses);
-  }
-  /**
-   * Processes the given address through the router, retrieving the AdgFunction if
-   * available.
-   * @param address to process
-   * @returns AdgRoutingResult encapsulating the status, original address, and adgFn
-   */
-
-
-  processAddress(address) {
-    const userSchemaData = {
-      page: JSON.stringify(address)
-    };
-    let resolveViewResult;
-
-    try {
-      resolveViewResult = this.router.resolveView(address);
-    } catch (err) {
-      this._instrumentation.error(err, prefetchSchema, userSchemaData, this.apiOptions);
-
-      return Promise.resolve(this.getErrorAddress(address, 'Unexpected exception during routing: ' + err?.message));
+    /**
+     * Processes the given address through the router, retrieving the AdgFunction if
+     * available.
+     * @param address to process
+     * @returns AdgRoutingResult encapsulating the status, original address, and adgFn
+     */
+    processAddress(address) {
+        const userSchemaData = { page: JSON.stringify(address) };
+        let resolveViewResult;
+        try {
+            resolveViewResult = this.router.resolveView(address);
+        }
+        catch (err) {
+            this._instrumentation.error(err, prefetchSchema, userSchemaData, this.apiOptions);
+            return Promise.resolve(this.getErrorAddress(address, 'Unexpected exception during routing: ' + (err === null || err === void 0 ? void 0 : err.message)));
+        }
+        return resolveViewResult
+            .then((destination) => {
+            return this.onRoutingResult(address, destination);
+        })
+            .then((value) => {
+            this._instrumentation.log(prefetchSchema, userSchemaData, this.apiOptions);
+            return value;
+        })
+            .catch((err) => {
+            this._instrumentation.error(err, prefetchSchema, userSchemaData, this.apiOptions);
+            return this.getErrorAddress(address, (err === null || err === void 0 ? void 0 : err.message)
+                ? 'Unexpected exception processing routing result: ' +
+                    (err === null || err === void 0 ? void 0 : err.message)
+                : 'Unknown exception processing routing result.');
+        });
     }
-
-    return resolveViewResult.then(destination => {
-      return this.onRoutingResult(address, destination);
-    }).then(value => {
-      this._instrumentation.log(prefetchSchema, userSchemaData, this.apiOptions);
-
-      return value;
-    }).catch(err => {
-      this._instrumentation.error(err, prefetchSchema, userSchemaData, this.apiOptions);
-
-      return this.getErrorAddress(address, err?.message ? 'Unexpected exception processing routing result: ' + err?.message : 'Unknown exception processing routing result.');
-    });
-  }
-
-  getErrorAddress(address, reason) {
-    return {
-      address,
-      success: false,
-      reason: reason
-    };
-  }
-  /**
-   * Determine if the router has an adg for the given address. For each result
-   * with an adg, group the address with other addresses that resolve to the same
-   * adg.
-   *
-   * @param address that resolves to this routingResult
-   * @param routingResult provided by the router for this address
-   * @returns adgRoutingResult
-   */
-
-
-  async onRoutingResult(address, routingResult) {
-    const adg = 'komaci';
-    const {
-      viewset = {}
-    } = routingResult;
-    let adgModuleImporter; // if routing handler only provides komaci view, use komaci module importer
-
-    if (viewset[adg]) {
-      adgModuleImporter = viewset[adg];
-    } else if (viewset['default']) {
-      // calculate komaci specifier using generic default viewset
-      const viewInfo = viewset['default'];
-
-      if (viewInfo) {
-        if (viewInfo.specifier) {
-          const komaciSpecifier = '@salesforce/komaci/' + viewInfo.specifier.replace('/', '__'); // create adgModuleImporter using komaciSpecifier
-
-          adgModuleImporter = () => import(komaciSpecifier);
+    getErrorAddress(address, reason) {
+        return {
+            address,
+            success: false,
+            reason: reason,
+        };
+    }
+    /**
+     * Determine if the router has an adg for the given address. For each result
+     * with an adg, group the address with other addresses that resolve to the same
+     * adg.
+     *
+     * @param address that resolves to this routingResult
+     * @param routingResult provided by the router for this address
+     * @returns adgRoutingResult
+     */
+    async onRoutingResult(address, routingResult) {
+        const adg = 'komaci';
+        const { viewset = {} } = routingResult;
+        let adgModuleImporter;
+        // if routing handler only provides komaci view, use komaci module importer
+        if (viewset[adg]) {
+            adgModuleImporter = viewset[adg];
+        }
+        else if (viewset['default']) {
+            // calculate komaci specifier using generic default viewset
+            const viewInfo = viewset['default'];
+            if (viewInfo) {
+                if (viewInfo.specifier) {
+                    const komaciSpecifier = '@salesforce/komaci/' + viewInfo.specifier.replace('/', '__');
+                    // create adgModuleImporter using komaciSpecifier
+                    adgModuleImporter = () => import(komaciSpecifier);
+                }
+            }
+        }
+        const adgModuleImport = await (adgModuleImporter === null || adgModuleImporter === void 0 ? void 0 : adgModuleImporter());
+        const adgRoutingResult = {
+            address,
+            success: false, // assume the worst
+        };
+        if (adgModuleImport === null || adgModuleImport === void 0 ? void 0 : adgModuleImport.default) {
+            const adgModule = adgModuleImport.default;
+            adgRoutingResult.success = true;
+            adgRoutingResult.adgModule = adgModule;
+            this.updateAdgMap(adgModule, address);
         }
-      }
+        else {
+            adgRoutingResult.reason = NO_ADG_MODULE_FOUND;
+        }
+        return adgRoutingResult;
     }
-
-    const adgModuleImport = await adgModuleImporter?.();
-    const adgRoutingResult = {
-      address,
-      success: false // assume the worst
-
-    };
-
-    if (adgModuleImport?.default) {
-      const adgModule = adgModuleImport.default;
-      adgRoutingResult.success = true;
-      adgRoutingResult.adgModule = adgModule;
-      this.updateAdgMap(adgModule, address);
-    } else {
-      adgRoutingResult.reason = NO_ADG_MODULE_FOUND;
+    /**
+     * Updates the adgMap with the given adgFn, creating the entry if needed
+     * and updating the pageReference array for the given address.
+     *
+     * @param adgModule adgModule that will act as a key in the map
+     * @param address address associated with this adgFn
+     */
+    updateAdgMap(adgModule, address) {
+        const addresses = this.adgMap.get(adgModule);
+        // check to see if adg has already been added, and append address to the list
+        if (addresses) {
+            // if highVolumePriming is enabled, we only wish to resolve each unique module once, so don't add additional addresses to the list for resolution
+            if (!this.config.highVolumePriming) {
+                addresses.push(address);
+            }
+        }
+        else {
+            // adg hasn't been added, create entry.
+            this.adgMap.set(adgModule, [address]);
+        }
     }
-
-    return adgRoutingResult;
-  }
-  /**
-   * Updates the adgMap with the given adgFn, creating the entry if needed
-   * and updating the pageReference array for the given address.
-   *
-   * @param adgModule adgModule that will act as a key in the map
-   * @param address address associated with this adgFn
-   */
-
-
-  updateAdgMap(adgModule, address) {
-    const addresses = this.adgMap.get(adgModule); // check to see if adg has already been added, and append address to the list
-
-    if (addresses) {
-      // if highVolumePriming is enabled, we only wish to resolve each unique module once, so don't add additional addresses to the list for resolution
-      if (!this.config.highVolumePriming) {
-        addresses.push(address);
-      }
-    } else {
-      // adg hasn't been added, create entry.
-      this.adgMap.set(adgModule, [address]);
+    /**
+     * Initiates the prefetch process for the given array of addresses.
+     * - Addresses are ran through the router to resolve their associated AdgModule, if any
+     * - Addresses that resolve to AdgModule are grouped together in order to be resolved in a batch
+     * - Addresses that do no resolve to an AdgModule are rejected
+     *
+     * @param addresses
+     */
+    prefetch(addresses) {
+        this.updateState(STATE.running);
+        this.processAllAddresses(addresses).then((adgRoutingResults) => {
+            const rejected = adgRoutingResults.filter(({ success }) => !success);
+            rejected.forEach(({ address: rejectedAddress, reason }) => {
+                const message = reason ||
+                    `${ERROR_PREFIX} Unknown exception processing routing result.`;
+                this.onAddressDone(rejectedAddress, 'rejected', [message]);
+            });
+            // if prefetch exclusively consists of unprocessable addresses, update state to done
+            if (rejected.length === adgRoutingResults.length) {
+                this.updateState(STATE.done, 'no processable addresses, do not bulkResolve and set state to "done"');
+            }
+            this.bulkResolveGuard();
+        });
     }
-  }
-  /**
-   * Initiates the prefetch process for the given array of addresses.
-   * - Addresses are ran through the router to resolve their associated AdgModule, if any
-   * - Addresses that resolve to AdgModule are grouped together in order to be resolved in a batch
-   * - Addresses that do no resolve to an AdgModule are rejected
-   *
-   * @param addresses
-   */
-
-
-  prefetch(addresses) {
-    this.updateState(STATE.running);
-    this.processAllAddresses(addresses).then(adgRoutingResults => {
-      const rejected = adgRoutingResults.filter(({
-        success
-      }) => !success);
-      rejected.forEach(({
-        address: rejectedAddress,
-        reason
-      }) => {
-        const message = reason || `${ERROR_PREFIX} Unknown exception processing routing result.`;
-        this.onAddressDone(rejectedAddress, 'rejected', [message]);
-      }); // if prefetch exclusively consists of unprocessable addresses, update state to done
-
-      if (rejected.length === adgRoutingResults.length) {
-        this.updateState(STATE.done, 'no processable addresses, do not bulkResolve and set state to "done"');
-      }
-
-      this.bulkResolveGuard();
-    });
-  }
-  /**
-   * Processes a list of addresses through the router in series
-   * @param addresses to process
-   * @returns { AdgRoutingResult[] } a list of AdgRoutingResult
-   */
-
-
-  async processAllAddresses(addresses) {
-    // add instrumentation to get total duration to process all addresses
-    const action = InstrumentedAction.startAction('komaci.router', totalRoutingSchema, {
-      instrumentWithoutLog: false,
-      postTimeInLog: true,
-      apiOptions: this.apiOptions
-    });
-    const results = [];
-    const maxConcurrent = this.config.maxConcurrent || Number.MAX_SAFE_INTEGER;
-
-    for (let i = 0; i < addresses.length; i += maxConcurrent) {
-      const processList = addresses.slice(i, Math.min(addresses.length, i + maxConcurrent));
-      results.push(...(await Promise.all(processList.map(address => this.processAddress(address)))));
+    /**
+     * Processes a list of addresses through the router in series
+     * @param addresses to process
+     * @returns { AdgRoutingResult[] } a list of AdgRoutingResult
+     */
+    async processAllAddresses(addresses) {
+        // add instrumentation to get total duration to process all addresses
+        const action = InstrumentedAction.startAction('komaci.router', totalRoutingSchema, {
+            instrumentWithoutLog: false,
+            postTimeInLog: true,
+            apiOptions: this.apiOptions,
+        });
+        const results = [];
+        const maxConcurrent = this.config.maxConcurrent || Number.MAX_SAFE_INTEGER;
+        for (let i = 0; i < addresses.length; i += maxConcurrent) {
+            const processList = addresses.slice(i, Math.min(addresses.length, i + maxConcurrent));
+            results.push(...(await Promise.all(processList.map((address) => this.processAddress(address)))));
+        }
+        action.finishAction(false, {});
+        return results;
     }
-
-    action.finishAction(false, {});
-    return results;
-  }
-  /**
-   * Split all the addresses based on the maxConcurrent configuration
-   * bulkResolve them in iterations
-   */
-
-
-  bulkResolveGuard() {
-    const maxConcurrent = this.config.maxConcurrent || Number.MAX_SAFE_INTEGER; // rest capacity when there are addresses being processed
-
-    let capacity = maxConcurrent;
-    const adgs = this.adgMap.keys();
-
-    for (const adgFn of adgs) {
-      const addresses = this.adgMap.get(adgFn);
-
-      if (addresses && addresses.length > 0) {
-        if (addresses.length > capacity) {
-          if (addresses.length < maxConcurrent) {
-            /* to benefits from batching,
-               we dont want to split addresses for same adg if they can be in same iteration
-               example: having maxConcurrent: 10
-                               adg1: 6 addresses
-                               adg2: 8 addresses
-               ideal way is two iterations for both adg1 and adg2 instead of iter1: 6 adg1 + 4 adg2, iter2: 4 adg2
-             in addition to the example, if there is another adg3: 4 addresses, will do
-                iter1: 6 adg1 + 4 adg3
-                iter2: 8 adg2
-            */
-            continue;
-          } // if the length of address have exceed the maxConcurrent,
-          // split/resolve and update the rest to adgMap
-
-
-          const currentIteration = addresses.slice(0, capacity);
-          this.adgMap.set(adgFn, addresses.slice(capacity));
-          this.bulkResolve(adgFn, currentIteration);
-          break;
-        } else {
-          // if the length of address can fit in the capacity,
-          // resolve them all and remove the entry from adgMap
-          capacity = capacity - addresses.length;
-          this.adgMap.delete(adgFn);
-          this.bulkResolve(adgFn, addresses);
+    /**
+     * Split all the addresses based on the maxConcurrent configuration
+     * bulkResolve them in iterations
+     */
+    bulkResolveGuard() {
+        const maxConcurrent = this.config.maxConcurrent || Number.MAX_SAFE_INTEGER;
+        // rest capacity when there are addresses being processed
+        let capacity = maxConcurrent;
+        const adgs = this.adgMap.keys();
+        for (const adgFn of adgs) {
+            const addresses = this.adgMap.get(adgFn);
+            if (addresses && addresses.length > 0) {
+                if (addresses.length > capacity) {
+                    if (addresses.length < maxConcurrent) {
+                        /* to benefits from batching,
+                           we dont want to split addresses for same adg if they can be in same iteration
+                           example: having maxConcurrent: 10
+                                           adg1: 6 addresses
+                                           adg2: 8 addresses
+                           ideal way is two iterations for both adg1 and adg2 instead of iter1: 6 adg1 + 4 adg2, iter2: 4 adg2
+
+                        in addition to the example, if there is another adg3: 4 addresses, will do
+                            iter1: 6 adg1 + 4 adg3
+                            iter2: 8 adg2
+                        */
+                        continue;
+                    }
+                    // if the length of address have exceed the maxConcurrent,
+                    // split/resolve and update the rest to adgMap
+                    const currentIteration = addresses.slice(0, capacity);
+                    this.adgMap.set(adgFn, addresses.slice(capacity));
+                    this.bulkResolve(adgFn, currentIteration);
+                    break;
+                }
+                else {
+                    // if the length of address can fit in the capacity,
+                    // resolve them all and remove the entry from adgMap
+                    capacity = capacity - addresses.length;
+                    this.adgMap.delete(adgFn);
+                    this.bulkResolve(adgFn, addresses);
+                }
+            }
+            else {
+                // in case of empty address list
+                this.adgMap.delete(adgFn);
+            }
         }
-      } else {
-        // in case of empty address list
-        this.adgMap.delete(adgFn);
-      }
     }
-  }
-  /**
-   * Resolves the given adgFunction with the given resolutionGroup
-   * @param adgFn to resolve for the inputs provided in the resolutionContext
-   * @param addresses the list of addresses to be placed into a new BulkResolver
-   */
-
-
-  bulkResolve(adgFn, addresses) {
-    if (this.state == STATE.stopped) {
-      return;
+    /**
+     * Resolves the given adgFunction with the given resolutionGroup
+     * @param adgFn to resolve for the inputs provided in the resolutionContext
+     * @param addresses the list of addresses to be placed into a new BulkResolver
+     */
+    bulkResolve(adgFn, addresses) {
+        if (this.state == STATE.stopped) {
+            return;
+        }
+        const action = InstrumentedAction.startAction('komaci', bulkResolveSchema, {
+            instrumentWithoutLog: false,
+            postTimeInLog: true,
+            apiOptions: this.apiOptions,
+        });
+        const adgInputs = addresses.map((address) => {
+            return {
+                properties: {},
+                context: {
+                    CurrentPageReference: address,
+                },
+            };
+        });
+        const resolverInputStatus = addresses.map(() => STATE.running);
+        const bulkResolutionGroup = {
+            addresses,
+            resolverInputStatus,
+        };
+        bulkResolutionGroup.adgInputs = adgInputs;
+        const bulkResolutionStatusCbs = {
+            bulkResolutionStatusCb: this.onBulkResolutionStatus.bind(this, bulkResolutionGroup, action),
+            overallBulkResolutionStatusCb: undefined,
+        };
+        const environmentCfg = {
+            instrumentationCtx: this.apiOptions.instrumentationContext,
+            downloadImageFunc: this.config.downloadImage,
+            MaxResolutionDepth: 512,
+            WireTimeout: 180 * 1000,
+            WireSlowRunningTimeout: 30 * 1000,
+        };
+        bulkResolutionGroup.bulkResolver = getBulkAdgResolver(adgFn, adgInputs, bulkResolutionStatusCbs, environmentCfg);
+        this.resolutionGroups.push(bulkResolutionGroup);
+        bulkResolutionGroup.bulkResolver.start();
     }
-
-    const action = InstrumentedAction.startAction('komaci', bulkResolveSchema, {
-      instrumentWithoutLog: false,
-      postTimeInLog: true,
-      apiOptions: this.apiOptions
-    });
-    const adgInputs = addresses.map(address => {
-      return {
-        properties: {},
-        context: {
-          CurrentPageReference: address
+    /**
+     * StatusCallback to BulkResolver, invoked when resolver emits a new status.
+     * Updates the prefetchService's status if applicable.
+     * @param bulkResolutionGroup
+     * @param action InstrumentationContext
+     * @param status
+     */
+    onBulkResolutionStatus(bulkResolutionGroup, action, status) {
+        var _a;
+        const state = status.status.getState();
+        const index = status.index;
+        const { addresses } = bulkResolutionGroup;
+        if (index >= 0 && index < addresses.length) {
+            bulkResolutionGroup.resolverInputStatus[index] = state;
+        }
+        else {
+            this.onUnexpectedCondition(`Invalid index provided by resolver: ${index}`);
+            return;
+        }
+        if ((_a = bulkResolutionGroup.bulkResolver) === null || _a === void 0 ? void 0 : _a.areAllResolversDone()) {
+            action.finishAction(false, {
+                userSchemaData: {
+                    keyCount: addresses.length,
+                },
+            });
+        }
+        switch (state) {
+            case STATE.done:
+                this.onResolutionDone(status, bulkResolutionGroup);
+                break;
+            case STATE.stopped:
+                // NOTE: Prefetch initiates stop, so this is a noop
+                break;
+            case STATE.running:
+                break;
+            default:
+                this.onUnexpectedCondition(`Unexpected resolution status: ${JSON.stringify(status)}`);
         }
-      };
-    });
-    const resolverInputStatus = addresses.map(() => STATE.running);
-    const bulkResolutionGroup = {
-      addresses,
-      resolverInputStatus
-    };
-    bulkResolutionGroup.adgInputs = adgInputs;
-    const bulkResolutionStatusCbs = {
-      bulkResolutionStatusCb: this.onBulkResolutionStatus.bind(this, bulkResolutionGroup, action),
-      overallBulkResolutionStatusCb: undefined
-    };
-    const environmentCfg = {
-      instrumentationCtx: this.apiOptions.instrumentationContext,
-      downloadImageFunc: this.config.downloadImage,
-      MaxResolutionDepth: 512,
-      WireTimeout: 180 * 1000,
-      WireSlowRunningTimeout: 30 * 1000
-    };
-    bulkResolutionGroup.bulkResolver = getBulkAdgResolver(adgFn, adgInputs, bulkResolutionStatusCbs, environmentCfg);
-    this.resolutionGroups.push(bulkResolutionGroup);
-    bulkResolutionGroup.bulkResolver.start();
-  }
-  /**
-   * StatusCallback to BulkResolver, invoked when resolver emits a new status.
-   * Updates the prefetchService's status if applicable.
-   * @param bulkResolutionGroup
-   * @param action InstrumentationContext
-   * @param status
-   */
-
-
-  onBulkResolutionStatus(bulkResolutionGroup, action, status) {
-    const state = status.status.getState();
-    const index = status.index;
-    const {
-      addresses
-    } = bulkResolutionGroup;
-
-    if (index >= 0 && index < addresses.length) {
-      bulkResolutionGroup.resolverInputStatus[index] = state;
-    } else {
-      this.onUnexpectedCondition(`Invalid index provided by resolver: ${index}`);
-      return;
     }
-
-    if (bulkResolutionGroup.bulkResolver?.areAllResolversDone()) {
-      action.finishAction(false, {
-        userSchemaData: {
-          keyCount: addresses.length
+    /**
+     * Stops all bulkResolvers
+     */
+    stop() {
+        if (this.state == STATE.stopped) {
+            return;
         }
-      });
+        this.resolutionGroups.forEach((bulkResolutionContext) => {
+            const { bulkResolver } = bulkResolutionContext;
+            if (bulkResolver) {
+                bulkResolver.stop();
+            }
+        });
+        this.updateState(STATE.stopped);
     }
-
-    switch (state) {
-      case STATE.done:
-        this.onResolutionDone(status, bulkResolutionGroup);
-        break;
-
-      case STATE.stopped:
-        // NOTE: Prefetch initiates stop, so this is a noop
-        break;
-
-      case STATE.running:
-        break;
-
-      default:
-        this.onUnexpectedCondition(`Unexpected resolution status: ${JSON.stringify(status)}`);
+    /**
+     * Called upon unexpected conditions that may indicate to the consumer that
+     * the prefetchService or its associated resolver is in an invalid state
+     * @param message
+     */
+    onUnexpectedCondition(message) {
+        // eslint-disable-next-line no-console
+        console.log(`Komaci/prefetch - error, message: ${message}`);
+        this._activity.error(message);
+        this.updateState(STATE.error, message);
     }
-  }
-  /**
-   * Stops all bulkResolvers
-   */
-
-
-  stop() {
-    if (this.state == STATE.stopped) {
-      return;
+    /**
+     * Called when resolution for a given address has completed, or was otherwise
+     * rejected.
+     * @param address that is done
+     * @param state completed when resolved, or rejected when either no ADG exists, or resolver emitted an error with the given address
+     * @param reasons reasons for rejected status, if any
+     */
+    onAddressDone(address, state, reasons) {
+        const { onAddressProcessed } = this.config;
+        const status = {
+            state: state,
+            address,
+            reasons: reasons,
+        };
+        try {
+            onAddressProcessed === null || onAddressProcessed === void 0 ? void 0 : onAddressProcessed(status);
+        }
+        catch (error) {
+            this.onUnexpectedCondition(error === null || error === void 0 ? void 0 : error.message);
+        }
     }
-
-    this.resolutionGroups.forEach(bulkResolutionContext => {
-      const {
-        bulkResolver
-      } = bulkResolutionContext;
-
-      if (bulkResolver) {
-        bulkResolver.stop();
-      }
-    });
-    this.updateState(STATE.stopped);
-  }
-  /**
-   * Called upon unexpected conditions that may indicate to the consumer that
-   * the prefetchService or its associated resolver is in an invalid state
-   * @param message
-   */
-
-
-  onUnexpectedCondition(message) {
-    // eslint-disable-next-line no-console
-    console.log(`Komaci/prefetch - error, message: ${message}`);
-
-    this._activity.error(message);
-
-    this.updateState(STATE.error, message);
-  }
-  /**
-   * Called when resolution for a given address has completed, or was otherwise
-   * rejected.
-   * @param address that is done
-   * @param state completed when resolved, or rejected when either no ADG exists, or resolver emitted an error with the given address
-   * @param reasons reasons for rejected status, if any
-   */
-
-
-  onAddressDone(address, state, reasons) {
-    const {
-      onAddressProcessed
-    } = this.config;
-    const status = {
-      state: state,
-      address,
-      reasons: reasons
-    };
-
-    try {
-      onAddressProcessed?.(status);
-    } catch (error) {
-      this.onUnexpectedCondition(error?.message);
+    /**
+     * Updates the current PrefetchState to done if every bulkResolver has emitted
+     * a non-running status for all inputs.
+     */
+    updateStateIfAllDone(bulkResolutionContext, status) {
+        const bulkContexts = this.resolutionGroups.values();
+        let allDone = true;
+        for (const context of bulkContexts) {
+            if (context.bulkResolver && !context.bulkResolver.areAllResolversDone()) {
+                allDone = false;
+                break;
+            }
+        }
+        if (allDone) {
+            if (this.adgMap.size > 0) {
+                // if all current runs are all done but with addresses left in the adgMap
+                // go process them
+                this.bulkResolveGuard();
+            }
+            else {
+                // prefetch is done when allIdel and nothing left in adgMap
+                // eslint-disable-next-line no-console
+                console.log(`Komaci/prefetch - duration: ${Date.now() - this._startTime}, size: ${this._size}.`);
+                this._activity.stop(prefetchServiceSchema, {
+                    addressCount: this._size,
+                    startTime: this._startTime,
+                });
+                this.updateState(STATE.done, status.status.getErrorMessages().join('\n'));
+                bulkResolutionContext.bulkResolver = undefined;
+            }
+        }
     }
-  }
-  /**
-   * Updates the current PrefetchState to done if every bulkResolver has emitted
-   * a non-running status for all inputs.
-   */
-
-
-  updateStateIfAllDone(bulkResolutionContext, status) {
-    const bulkContexts = this.resolutionGroups.values();
-    let allDone = true;
-
-    for (const context of bulkContexts) {
-      if (context.bulkResolver && !context.bulkResolver.areAllResolversDone()) {
-        allDone = false;
-        break;
-      }
+    /**
+     * Called when resolver emits a "sink" state for an address or all addresses
+     * @param status
+     * @param bulkResolutionContext
+     */
+    onResolutionDone(status, bulkResolutionContext) {
+        const index = status.index;
+        const { addresses } = bulkResolutionContext;
+        const addressState = status.status.getErrorMessages().length !== 0 ? 'rejected' : 'completed';
+        const impactedAddress = addresses[index];
+        this.onAddressDone(impactedAddress, addressState, status.status.getErrorMessages());
+        this.updateStateIfAllDone(bulkResolutionContext, status);
     }
-
-    if (allDone) {
-      if (this.adgMap.size > 0) {
-        // if all current runs are all done but with addresses left in the adgMap
-        // go process them
-        this.bulkResolveGuard();
-      } else {
-        // prefetch is done when allIdel and nothing left in adgMap
-        // eslint-disable-next-line no-console
-        console.log(`Komaci/prefetch - duration: ${Date.now() - this._startTime}, size: ${this._size}.`);
-
-        this._activity.stop(prefetchServiceSchema, {
-          addressCount: this._size,
-          startTime: this._startTime
-        });
-
-        this.updateState(STATE.done, status.status.getErrorMessages().join('\n'));
-        bulkResolutionContext.bulkResolver = undefined;
-      }
+    /**
+     * Updates PrefetchState and notifies consumer via config.onStateChanged callback
+     * @param newState the new state
+     * @param [message] state message, if any
+     */
+    updateState(newState, message) {
+        const { onStateChanged } = this.config;
+        const abandoned = []; // TODO: Abandoned Not yet implemented
+        if (ValidStatusTransitions.isValid(this.state, newState)) {
+            this.state = newState;
+            try {
+                onStateChanged === null || onStateChanged === void 0 ? void 0 : onStateChanged({
+                    state: newState,
+                    abandoned,
+                    message,
+                });
+            }
+            catch (error) {
+                // eslint-disable-next-line no-console
+                console.log(error === null || error === void 0 ? void 0 : error.message);
+            }
+        }
+        else {
+            const errorMessage = `Komaci/prefetch - Invalid state transition from resovler. Resolver emitted state: ${newState} while prefetch is in ${this.state}`;
+            // eslint-disable-next-line no-console
+            console.log(errorMessage);
+            this._activity.error(errorMessage, 'invalid-prefetch-state-transition');
+        }
     }
-  }
-  /**
-   * Called when resolver emits a "sink" state for an address or all addresses
-   * @param status
-   * @param bulkResolutionContext
-   */
-
-
-  onResolutionDone(status, bulkResolutionContext) {
-    const index = status.index;
-    const {
-      addresses
-    } = bulkResolutionContext;
-    const addressState = status.status.getErrorMessages().length !== 0 ? 'rejected' : 'completed';
-    const impactedAddress = addresses[index];
-    this.onAddressDone(impactedAddress, addressState, status.status.getErrorMessages());
-    this.updateStateIfAllDone(bulkResolutionContext, status);
-  }
-  /**
-   * Updates PrefetchState and notifies consumer via config.onStateChanged callback
-   * @param newState the new state
-   * @param [message] state message, if any
-   */
-
-
-  updateState(newState, message) {
-    const {
-      onStateChanged
-    } = this.config;
-    const abandoned = []; // TODO: Abandoned Not yet implemented
-
-    if (ValidStatusTransitions.isValid(this.state, newState)) {
-      this.state = newState;
-
-      try {
-        onStateChanged?.({
-          state: newState,
-          abandoned,
-          message
-        });
-      } catch (error) {
-        // eslint-disable-next-line no-console
-        console.log(error?.message);
-      }
-    } else {
-      const errorMessage = `Komaci/prefetch - Invalid state transition from resovler. Resolver emitted state: ${newState} while prefetch is in ${this.state}`; // eslint-disable-next-line no-console
-
-      console.log(errorMessage);
-
-      this._activity.error(errorMessage, 'invalid-prefetch-state-transition');
+    getState() {
+        return this.state;
     }
-  }
-
-  getState() {
-    return this.state;
-  }
-
-}
+}
+//# sourceMappingURL=prefetchService.js.map

package/build/modules/komaci/prefetchTypes/prefetchTypes.js

@@ -1,30 +1,22 @@
 export const ERROR_PREFIX = '[komaci prefetch]';
-/**
- * Routing result for each address
- */
-
-export let ResolutionStatusState;
-
+export var ResolutionStatusState;
 (function (ResolutionStatusState) {
-  ResolutionStatusState["running"] = "running";
-  ResolutionStatusState["done"] = "done";
-  ResolutionStatusState["error"] = "error";
-  ResolutionStatusState["stopped"] = "stopped";
+    ResolutionStatusState["running"] = "running";
+    ResolutionStatusState["done"] = "done";
+    ResolutionStatusState["error"] = "error";
+    ResolutionStatusState["stopped"] = "stopped";
 })(ResolutionStatusState || (ResolutionStatusState = {}));
-
-export let PrefetchStatusStates;
-
+export var PrefetchStatusStates;
 (function (PrefetchStatusStates) {
-  PrefetchStatusStates["init"] = "init";
-  PrefetchStatusStates["done"] = "done";
-  PrefetchStatusStates["running"] = "running";
-  PrefetchStatusStates["stopped"] = "stopped";
-  PrefetchStatusStates["error"] = "error";
+    PrefetchStatusStates["init"] = "init";
+    PrefetchStatusStates["done"] = "done";
+    PrefetchStatusStates["running"] = "running";
+    PrefetchStatusStates["stopped"] = "stopped";
+    PrefetchStatusStates["error"] = "error";
 })(PrefetchStatusStates || (PrefetchStatusStates = {}));
-
-export let AddressStatusStates;
-
+export var AddressStatusStates;
 (function (AddressStatusStates) {
-  AddressStatusStates["completed"] = "completed";
-  AddressStatusStates["rejected"] = "rejected";
-})(AddressStatusStates || (AddressStatusStates = {}));
+    AddressStatusStates["completed"] = "completed";
+    AddressStatusStates["rejected"] = "rejected";
+})(AddressStatusStates || (AddressStatusStates = {}));
+//# sourceMappingURL=prefetchTypes.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@komaci/prefetch",
-    "version": "242.1.9",
+    "version": "242.2.1",
     "description": "Komaci prefetch service.",
     "homepage": "https://komaci.dev/",
     "repository": {
@@ -19,21 +19,21 @@
     "types": "build/modules/komaci/prefetchTypes/prefetchTypes.d.ts",
     "main": "build/index.js",
     "scripts": {
-        "build": "node ../../../bin/pack-ts --dir src/modules build/modules && tsc -b ./tsconfig.json"
+        "build": "tsc -b"
     },
     "files": [
         "build/**/*.js",
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@komaci/module-shared": "242.1.9",
-        "@komaci/resolver": "242.1.9",
+        "@komaci/module-shared": "242.2.1",
+        "@komaci/resolver": "242.2.1",
         "@lwrjs/router": "0.6.0-alpha.15",
         "o11y": "^240.7.0",
         "o11y_schema": "^240.11.0"
     },
     "devDependencies": {
-        "@komaci/types": "242.1.9",
+        "@komaci/types": "242.2.1",
         "wait-for-expect": "^3.0.2"
     }
 }