@configura/web-api 1.5.0 → 1.6.0-iotest.1

package/dist/index.d.ts

@@ -1,19 +1,23 @@
-export * from "./CatalogueAPI.js";
-export * from "./CfgProduct.js";
-export * from "./material/CfgMaterialMapping.js";
-export * from "./material/CfgMtrlApplication.js";
-export * from "./material/CfgMtrlApplicationSource.js";
-export * from "./material/CfgMtrlSource.js";
-export * from "./material/CfgMtrlSourceWithMetaData.js";
-export * from "./productConfiguration/CfgFeature.js";
-export * from "./productConfiguration/CfgOption.js";
-export * from "./productConfiguration/CfgProductConfiguration.js";
-export * from "./productConfiguration/filters.js";
-export * from "./productConfiguration/productParamsGenerator.js";
-export * from "./productLoader.js";
-export * from "./tasks/formats.js";
-export * from "./tasks/TaskHandler.js";
-export * from "./utilitiesCatalogueData.js";
-export * from "./utilitiesCataloguePermission.js";
-export * from "./utilitiesNumericValues.js";
+export * from "./CatalogueAPI.js";
+export * from "./CfgProduct.js";
+export * from "./io/CfgHistoryManager.js";
+export * from "./io/CfgHistoryToProdConfConnector.js";
+export * from "./io/CfgWindowMessageManager.js";
+export * from "./io/CfgWindowMessageToProdConfConnector.js";
+export * from "./material/CfgMaterialMapping.js";
+export * from "./material/CfgMtrlApplication.js";
+export * from "./material/CfgMtrlApplicationSource.js";
+export * from "./material/CfgMtrlSource.js";
+export * from "./material/CfgMtrlSourceWithMetaData.js";
+export * from "./productConfiguration/CfgFeature.js";
+export * from "./productConfiguration/CfgOption.js";
+export * from "./productConfiguration/CfgProductConfiguration.js";
+export * from "./productConfiguration/filters.js";
+export * from "./productConfiguration/productParamsGenerator.js";
+export * from "./productLoader.js";
+export * from "./tasks/formats.js";
+export * from "./tasks/TaskHandler.js";
+export * from "./utilitiesCatalogueData.js";
+export * from "./utilitiesCataloguePermission.js";
+export * from "./utilitiesNumericValues.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,18 +1,22 @@
-export * from "./CatalogueAPI.js";
-export * from "./CfgProduct.js";
-export * from "./material/CfgMaterialMapping.js";
-export * from "./material/CfgMtrlApplication.js";
-export * from "./material/CfgMtrlApplicationSource.js";
-export * from "./material/CfgMtrlSource.js";
-export * from "./material/CfgMtrlSourceWithMetaData.js";
-export * from "./productConfiguration/CfgFeature.js";
-export * from "./productConfiguration/CfgOption.js";
-export * from "./productConfiguration/CfgProductConfiguration.js";
-export * from "./productConfiguration/filters.js";
-export * from "./productConfiguration/productParamsGenerator.js";
-export * from "./productLoader.js";
-export * from "./tasks/formats.js";
-export * from "./tasks/TaskHandler.js";
-export * from "./utilitiesCatalogueData.js";
-export * from "./utilitiesCataloguePermission.js";
-export * from "./utilitiesNumericValues.js";
+export * from "./CatalogueAPI.js";
+export * from "./CfgProduct.js";
+export * from "./io/CfgHistoryManager.js";
+export * from "./io/CfgHistoryToProdConfConnector.js";
+export * from "./io/CfgWindowMessageManager.js";
+export * from "./io/CfgWindowMessageToProdConfConnector.js";
+export * from "./material/CfgMaterialMapping.js";
+export * from "./material/CfgMtrlApplication.js";
+export * from "./material/CfgMtrlApplicationSource.js";
+export * from "./material/CfgMtrlSource.js";
+export * from "./material/CfgMtrlSourceWithMetaData.js";
+export * from "./productConfiguration/CfgFeature.js";
+export * from "./productConfiguration/CfgOption.js";
+export * from "./productConfiguration/CfgProductConfiguration.js";
+export * from "./productConfiguration/filters.js";
+export * from "./productConfiguration/productParamsGenerator.js";
+export * from "./productLoader.js";
+export * from "./tasks/formats.js";
+export * from "./tasks/TaskHandler.js";
+export * from "./utilitiesCatalogueData.js";
+export * from "./utilitiesCataloguePermission.js";
+export * from "./utilitiesNumericValues.js";

package/dist/io/CfgHistoryManager.d.ts

@@ -0,0 +1,30 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgHistoryManagerSendData<D> = {
+    message: D;
+    qsKeyValues: Map<string, string | undefined> | undefined;
+};
+/**
+ * Instantiating the class will use the history api to update your
+ * url with configuration changes
+ * Only handles configuration, not product
+ */
+export declare class CfgHistoryManager<D extends {
+    initial: boolean;
+}> extends CfgIOManager<"popstate", CfgHistoryManagerSendData<D>> {
+    private readonly _useHistoryPush;
+    /**
+     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     */
+    constructor(_useHistoryPush: boolean);
+    protected doSend(messageKey: string, data: CfgHistoryManagerSendData<D>): void;
+    private static _makeUpdatedUrl;
+    private static _makeUpdatedQueryString;
+    /**
+     * @returns The current query string as a Map
+     */
+    static _currentQsKeyValues(): Map<string, string>;
+    private static _makeUpdatedState;
+    protected readonly eventType = "popstate";
+    protected getDataFromEvent(event: PopStateEvent): unknown;
+}
+//# sourceMappingURL=CfgHistoryManager.d.ts.map

package/dist/io/CfgHistoryManager.js

@@ -0,0 +1,62 @@
+import { mapQueryString, unmapQueryString } from "@configura/web-utilities";
+import { CfgIOManager } from "./CfgIOManager.js";
+/**
+ * Instantiating the class will use the history api to update your
+ * url with configuration changes
+ * Only handles configuration, not product
+ */
+export class CfgHistoryManager extends CfgIOManager {
+    /**
+     * @param _useHistoryPush As opposed to replace. Push makes the web browser navigation buttons navigate configuration changes. Replace just updates the URL.
+     */
+    constructor(_useHistoryPush) {
+        super();
+        this._useHistoryPush = _useHistoryPush;
+        this.eventType = "popstate";
+    }
+    doSend(messageKey, data) {
+        const { qsKeyValues, message } = data;
+        const newUrl = qsKeyValues === undefined ? null : CfgHistoryManager._makeUpdatedUrl(qsKeyValues);
+        const newState = CfgHistoryManager._makeUpdatedState(message, messageKey);
+        if (!message.initial && this._useHistoryPush) {
+            window.history.pushState(newState, "", newUrl);
+        }
+        else {
+            window.history.replaceState(newState, "", newUrl);
+        }
+    }
+    static _makeUpdatedUrl(qsKeyValues) {
+        const qs = this._makeUpdatedQueryString(qsKeyValues);
+        return `${window.location.origin}${window.location.pathname}${qs ? "?" : ""}${qs}${window.location.hash}`;
+    }
+    static _makeUpdatedQueryString(qsKeyValues) {
+        const currentKeyValues = this._currentQsKeyValues();
+        for (const [key, value] of qsKeyValues) {
+            if (value === undefined) {
+                currentKeyValues.delete(key);
+            }
+            else {
+                currentKeyValues.set(key, value);
+            }
+        }
+        return unmapQueryString(currentKeyValues);
+    }
+    /**
+     * @returns The current query string as a Map
+     */
+    static _currentQsKeyValues() {
+        return mapQueryString(window.location.search);
+    }
+    static _makeUpdatedState(message, messageKey) {
+        let messages = {};
+        const currentState = window.history.state;
+        if (CfgIOManager.isIOContainer(currentState)) {
+            messages = currentState.messages;
+        }
+        messages[messageKey] = message;
+        return CfgIOManager.makeContainer(messages);
+    }
+    getDataFromEvent(event) {
+        return event.state;
+    }
+}

package/dist/io/CfgHistoryToProdConfConnector.d.ts

@@ -0,0 +1,10 @@
+import { CfgHistoryManager, CfgHistoryManagerSendData } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector, CfgProdConfMessage } from "./CfgIOProdConfConnector.js";
+export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
+export declare class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector<"popstate", CfgHistoryManagerSendData<CfgProdConfMessage>, CfgHistoryManager<CfgProdConfMessage>> {
+    private readonly _qsKey;
+    constructor(manager: CfgHistoryManager<CfgProdConfMessage>, _qsKey?: string, doValidate?: boolean);
+    protected getInitialProdConf(): string | undefined;
+    protected makeSendData(prodConfAsString: string, initial: boolean): CfgHistoryManagerSendData<CfgProdConfMessage>;
+}
+//# sourceMappingURL=CfgHistoryToProdConfConnector.d.ts.map

package/dist/io/CfgHistoryToProdConfConnector.js

@@ -0,0 +1,20 @@
+import { CfgHistoryManager } from "./CfgHistoryManager.js";
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+export const STAGE_PROD_CONF_MESSAGE_KEY = "stageprodconf";
+export class CfgHistoryToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, _qsKey = STAGE_PROD_CONF_MESSAGE_KEY, doValidate = true) {
+        super(manager, doValidate);
+        this._qsKey = _qsKey;
+    }
+    getInitialProdConf() {
+        return CfgHistoryManager._currentQsKeyValues().get(this._qsKey);
+    }
+    makeSendData(prodConfAsString, initial) {
+        return {
+            message: this.makeMessage(prodConfAsString, initial),
+            qsKeyValues: initial
+                ? undefined
+                : new Map([[STAGE_PROD_CONF_MESSAGE_KEY, prodConfAsString]]),
+        };
+    }
+}

package/dist/io/CfgIOManager.d.ts

@@ -0,0 +1,29 @@
+declare type ConfiguraShebang = "c0nf1guraarug1fn0c";
+declare type Listener = (m: unknown) => Promise<void>;
+export declare type CfgIOContainer = {
+    shebang: ConfiguraShebang;
+    messages: {
+        [index: string]: unknown;
+    };
+};
+export declare abstract class CfgIOManager<K extends keyof WindowEventMap, S> {
+    static isIOContainer: (data: any) => data is CfgIOContainer;
+    static hasIOContainerMessageKey: (container: CfgIOContainer, messageKey: string) => boolean;
+    static getMessageFromIOContainer: (container: any, messageKey: string) => unknown;
+    static makeContainer: (messages: {
+        [index: string]: unknown;
+    }) => CfgIOContainer;
+    private _inhibitSend;
+    private _listeners;
+    private _getIndexOfListener;
+    listen: (l: Listener, messageKey: string) => void;
+    stopListen: (l: Listener) => void;
+    private _containerListenerBound;
+    protected _containerListener(event: WindowEventMap[K]): void;
+    send: (messageKey: string, data: S) => void;
+    protected abstract doSend(messageKey: string, data: S): void;
+    protected abstract readonly eventType: K;
+    protected abstract getDataFromEvent(event: WindowEventMap[K]): unknown;
+}
+export {};
+//# sourceMappingURL=CfgIOManager.d.ts.map

package/dist/io/CfgIOManager.js

@@ -0,0 +1,89 @@
+const CONFIGURA_SHEBANG = "c0nf1guraarug1fn0c";
+export class CfgIOManager {
+    constructor() {
+        // A lock to avoid circular write
+        this._inhibitSend = false;
+        this._listeners = [];
+        this._getIndexOfListener = (l) => this._listeners.findIndex((item) => l === item.l);
+        this.listen = (l, messageKey) => {
+            if (this._getIndexOfListener(l) !== -1) {
+                console.warn("Tried to add listener twice");
+                return;
+            }
+            const startListenToWindow = this._listeners.length === 0;
+            this._listeners.push({ l, messageKey });
+            if (startListenToWindow) {
+                window.addEventListener(this.eventType, this._containerListenerBound);
+            }
+        };
+        this.stopListen = (l) => {
+            const i = this._getIndexOfListener(l);
+            if (i === -1) {
+                console.warn("Tried to stopListen on unknown listener");
+                return;
+            }
+            this._listeners.splice(i, 1);
+            if (this._listeners.length === 0) {
+                window.removeEventListener(this.eventType, this._containerListenerBound);
+            }
+        };
+        this._containerListenerBound = this._containerListener.bind(this);
+        this.send = (messageKey, data) => {
+            if (this._inhibitSend) {
+                return;
+            }
+            this.doSend(messageKey, data);
+        };
+    }
+    _containerListener(event) {
+        const data = this.getDataFromEvent(event);
+        if (!CfgIOManager.isIOContainer(data)) {
+            return;
+        }
+        // The 15 or so rows below is one of the cases where I believe building a clever
+        // data structure of so would probably be worse for performance than just looping
+        // as the subscribers are expected to be very few
+        const listeners = this._listeners;
+        const allMessageKeys = listeners.reduce((a, c) => {
+            a.add(c.messageKey);
+            return a;
+        }, new Set());
+        this._inhibitSend = true;
+        const promises = [];
+        for (const messageKey of allMessageKeys) {
+            if (!CfgIOManager.hasIOContainerMessageKey(data, messageKey)) {
+                continue;
+            }
+            const message = CfgIOManager.getMessageFromIOContainer(data, messageKey);
+            for (const item of listeners) {
+                if (item.messageKey !== messageKey) {
+                    continue;
+                }
+                promises.push(item.l(message));
+            }
+        }
+        Promise.all(promises)
+            .then(() => {
+            this._inhibitSend = false;
+        })
+            .catch(() => {
+            this._inhibitSend = false;
+        });
+    }
+}
+CfgIOManager.isIOContainer = (data) => data && data.shebang === CONFIGURA_SHEBANG;
+CfgIOManager.hasIOContainerMessageKey = (container, messageKey) => messageKey in container.messages;
+CfgIOManager.getMessageFromIOContainer = (container, messageKey) => {
+    if (!CfgIOManager.isIOContainer(container)) {
+        throw new Error("The passed data was not a CfgIOContainer. It is to be expected that such data messages can arrive, so please use isIOContainer function to filter them out before calling this.");
+    }
+    if (!CfgIOManager.hasIOContainerMessageKey(container, messageKey)) {
+        throw new Error(`The passed data did not have the messageKey "${messageKey}". You can test for this using hasIOContainerMessageKey function.`);
+    }
+    // It is assumed that if a message arrives with the right subMessageKey it can cast to T
+    return container.messages[messageKey];
+};
+CfgIOManager.makeContainer = (messages) => ({
+    shebang: CONFIGURA_SHEBANG,
+    messages,
+});

package/dist/io/CfgIOProdConfConnector.d.ts

@@ -0,0 +1,31 @@
+import { CfgProduct, CfgProductChangeNotification } from "../CfgProduct.js";
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgProdConfMessage = {
+    version: string;
+    initial: boolean;
+    prodConfAsString: string;
+};
+export declare const STAGE_PROD_CONF_MESSAGE_KEY = "stageProdConf";
+export declare const STAGE_PROD_CONF_MESSAGE_VERSION = "1.0";
+export declare type ProdConfCallback = (prodConfAsString: string) => Promise<void>;
+export declare abstract class CfgIOProdConfConnector<K extends keyof WindowEventMap, S, M extends CfgIOManager<K, S>> {
+    protected readonly _ioManager: M;
+    protected readonly _doValidate: boolean;
+    protected _product: CfgProduct | undefined;
+    private _stopListenToMessage;
+    private _stopListenToProdConf;
+    constructor(_ioManager: M, _doValidate: boolean);
+    setProduct: (product: CfgProduct | undefined) => Promise<void>;
+    protected abstract getInitialProdConf(): string | undefined;
+    protected abstract makeSendData(prodConfAsString: string, initial: boolean): S;
+    makeMessage(prodConfAsString: string, initial: boolean): CfgProdConfMessage;
+    makeMessageListener(callback: ProdConfCallback): (message: unknown) => Promise<void>;
+    /**
+     * Register the callback to listen for Product Configuration messages
+     * @returns A function which when called will cancel listening
+     */
+    listenForMessage(callback: ProdConfCallback): () => void;
+    makeProdConfListener(callback: ProdConfCallback): (n: CfgProductChangeNotification) => void;
+    listenForProdConf(product: CfgProduct, callback: ProdConfCallback): () => void;
+}
+//# sourceMappingURL=CfgIOProdConfConnector.d.ts.map

package/dist/io/CfgIOProdConfConnector.js

@@ -0,0 +1,98 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const STAGE_PROD_CONF_MESSAGE_KEY = "stageProdConf";
+export const STAGE_PROD_CONF_MESSAGE_VERSION = "1.0";
+export class CfgIOProdConfConnector {
+    constructor(_ioManager, _doValidate) {
+        this._ioManager = _ioManager;
+        this._doValidate = _doValidate;
+        this._stopListenToMessage = undefined;
+        this._stopListenToProdConf = undefined;
+        this.setProduct = (product) => __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const currentProduct = this._product;
+            const newProduct = product;
+            this._product = newProduct;
+            // If same product don't do anything at all
+            if (currentProduct !== undefined &&
+                newProduct !== undefined &&
+                currentProduct.isBackedBySame(newProduct)) {
+                return;
+            }
+            if (currentProduct !== undefined) {
+                (_a = this._stopListenToMessage) === null || _a === void 0 ? void 0 : _a.call(this);
+                (_b = this._stopListenToProdConf) === null || _b === void 0 ? void 0 : _b.call(this);
+            }
+            if (newProduct === undefined) {
+                return;
+            }
+            if (currentProduct === undefined) {
+                const initialProdConf = this.getInitialProdConf();
+                if (initialProdConf !== undefined) {
+                    yield newProduct.setFromApiSelectionString(initialProdConf, this._doValidate);
+                }
+            }
+            this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, this.makeSendData(newProduct.getApiSelectionAsString(), true));
+            this._stopListenToMessage = this.listenForMessage((prodConfAsString) => __awaiter(this, void 0, void 0, function* () {
+                if (prodConfAsString === newProduct.getApiSelectionAsString()) {
+                    return;
+                }
+                yield newProduct.setFromApiSelectionString(prodConfAsString, this._doValidate);
+            }));
+            this._stopListenToProdConf = this.listenForProdConf(newProduct, (prodConfAsString) => __awaiter(this, void 0, void 0, function* () {
+                this._ioManager.send(STAGE_PROD_CONF_MESSAGE_KEY, this.makeSendData(prodConfAsString, false));
+            }));
+        });
+    }
+    makeMessage(prodConfAsString, initial) {
+        return {
+            version: STAGE_PROD_CONF_MESSAGE_VERSION,
+            initial,
+            prodConfAsString,
+        };
+    }
+    makeMessageListener(callback) {
+        return (message) => __awaiter(this, void 0, void 0, function* () {
+            const { version, prodConfAsString } = message;
+            if (version !== "1.0") {
+                console.error(`The a message was passed with an unsupported version "${version}". Currently only ${STAGE_PROD_CONF_MESSAGE_VERSION} is supported.`);
+                return;
+            }
+            yield callback(prodConfAsString);
+        });
+    }
+    /**
+     * Register the callback to listen for Product Configuration messages
+     * @returns A function which when called will cancel listening
+     */
+    listenForMessage(callback) {
+        const ioManager = this._ioManager;
+        const listener = this.makeMessageListener(callback);
+        ioManager.listen(listener, STAGE_PROD_CONF_MESSAGE_KEY);
+        return () => {
+            ioManager.stopListen(listener);
+        };
+    }
+    makeProdConfListener(callback) {
+        return (n) => {
+            if (!n.committed) {
+                return;
+            }
+            callback(n.freshRef.getApiSelectionAsString());
+        };
+    }
+    listenForProdConf(product, callback) {
+        const listener = this.makeProdConfListener(callback);
+        product.listenForChange(listener);
+        return () => {
+            product.stopListenForChange(listener);
+        };
+    }
+}

package/dist/io/CfgWindowMessageManager.d.ts

@@ -0,0 +1,13 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export declare type CfgWindowMessageManagerSendData = unknown;
+export declare class CfgWindowMessageManager extends CfgIOManager<"message", CfgWindowMessageManagerSendData> {
+    private readonly _remoteEnds;
+    private readonly _targetOrigin;
+    private readonly _acceptableMessageOrigin?;
+    constructor(_remoteEnds: Window[], _targetOrigin?: string, _acceptableMessageOrigin?: string | undefined);
+    protected doSend(messageKey: string, data: unknown): void;
+    protected _containerListener(event: MessageEvent<any>): void;
+    protected readonly eventType = "message";
+    protected getDataFromEvent(event: MessageEvent<any>): unknown;
+}
+//# sourceMappingURL=CfgWindowMessageManager.d.ts.map

package/dist/io/CfgWindowMessageManager.js

@@ -0,0 +1,28 @@
+import { CfgIOManager } from "./CfgIOManager.js";
+export class CfgWindowMessageManager extends CfgIOManager {
+    constructor(_remoteEnds, _targetOrigin = "*", _acceptableMessageOrigin) {
+        super();
+        this._remoteEnds = _remoteEnds;
+        this._targetOrigin = _targetOrigin;
+        this._acceptableMessageOrigin = _acceptableMessageOrigin;
+        this.eventType = "message";
+    }
+    doSend(messageKey, data) {
+        const container = CfgIOManager.makeContainer({
+            [messageKey]: data,
+        });
+        for (const remoteEnd of this._remoteEnds) {
+            remoteEnd.postMessage(container, this._targetOrigin);
+        }
+    }
+    _containerListener(event) {
+        if (this._acceptableMessageOrigin !== undefined &&
+            event.origin !== this._acceptableMessageOrigin) {
+            return;
+        }
+        super._containerListener(event);
+    }
+    getDataFromEvent(event) {
+        return event.data;
+    }
+}

package/dist/io/CfgWindowMessageToProdConfConnector.d.ts

@@ -0,0 +1,13 @@
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+import { CfgWindowMessageManager, CfgWindowMessageManagerSendData } from "./CfgWindowMessageManager.js";
+/**
+ * Instantiating the class will expose your product to:
+ * - Listen for configuration changes posted to this window
+ * - Send configuration changes using sendMessage
+ */
+export declare class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector<"message", CfgWindowMessageManagerSendData, CfgWindowMessageManager> {
+    constructor(manager: CfgWindowMessageManager, doValidate?: boolean);
+    protected getInitialProdConf(): string | undefined;
+    protected makeSendData(prodConfAsString: string, initial: boolean): CfgWindowMessageManagerSendData;
+}
+//# sourceMappingURL=CfgWindowMessageToProdConfConnector.d.ts.map

package/dist/io/CfgWindowMessageToProdConfConnector.js

@@ -0,0 +1,17 @@
+import { CfgIOProdConfConnector } from "./CfgIOProdConfConnector.js";
+/**
+ * Instantiating the class will expose your product to:
+ * - Listen for configuration changes posted to this window
+ * - Send configuration changes using sendMessage
+ */
+export class CfgWindowMessageToProdConfConnector extends CfgIOProdConfConnector {
+    constructor(manager, doValidate = true) {
+        super(manager, doValidate);
+    }
+    getInitialProdConf() {
+        return undefined;
+    }
+    makeSendData(prodConfAsString, initial) {
+        return this.makeMessage(prodConfAsString, initial);
+    }
+}

package/dist/material/CfgMaterialMapping.d.ts

@@ -1,8 +1,8 @@
-import { CfgProductConfiguration } from "../productConfiguration/CfgProductConfiguration.js";
-import { CfgMtrlApplication } from "./CfgMtrlApplication.js";
-import { CfgMtrlSourceWithMetaData } from "./CfgMtrlSourceWithMetaData.js";
-export declare type CfgMaterialMapping = Map<string, CfgMtrlSourceWithMetaData>;
-export declare function aggregateAllMaterialApplications(applicationAreas: CfgMtrlApplication[], productMtrlApplications: CfgMtrlApplication[], productConfiguration: CfgProductConfiguration, debugMtrlApplications?: CfgMtrlApplication[]): CfgMaterialMapping;
-export declare function logMtrlSourceWithMetaDataToConsole(mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData): void;
-export declare function logMaterialMappingToConsole(areasToMaterials: CfgMaterialMapping): void;
+import { CfgProductConfiguration } from "../productConfiguration/CfgProductConfiguration.js";
+import { CfgMtrlApplication } from "./CfgMtrlApplication.js";
+import { CfgMtrlSourceWithMetaData } from "./CfgMtrlSourceWithMetaData.js";
+export declare type CfgMaterialMapping = Map<string, CfgMtrlSourceWithMetaData>;
+export declare function aggregateAllMaterialApplications(applicationAreas: CfgMtrlApplication[], productMtrlApplications: CfgMtrlApplication[], productConfiguration: CfgProductConfiguration, debugMtrlApplications?: CfgMtrlApplication[]): CfgMaterialMapping;
+export declare function logMtrlSourceWithMetaDataToConsole(mtrlSourceWithMetaData: CfgMtrlSourceWithMetaData): void;
+export declare function logMaterialMappingToConsole(areasToMaterials: CfgMaterialMapping): void;
 //# sourceMappingURL=CfgMaterialMapping.d.ts.map