@configura/web-api 1.6.0-iotest.2 → 1.6.1-alpha.1

package/dist/tests/testData/testDataOptions.d.ts

@@ -0,0 +1,13 @@
+import { Option, SelectedOption } from "../../CatalogueAPI.js";
+export declare function addDefaultsToMockSelectedOption(root: SelectedOption, optionCodeToAdd: string | undefined, optionCodesToRemove: string[], unlessOptionCodes: string[]): void;
+export declare const letterOptionCodeA = "optA";
+export declare const letterOptionCodeB = "optB";
+export declare const letterOptionCodeC = "optC";
+export declare const letterOptionCodeD = "optD";
+export declare const letterOptionCodeE = "optE";
+export declare const letterOptionCodeF = "optF";
+export declare const letterOptions: Option[];
+export declare const toggleOptionCodeOff = "optOff";
+export declare const toggleOptionCodeOn = "optOn";
+export declare const toggleOptions: Option[];
+//# sourceMappingURL=testDataOptions.d.ts.map

package/dist/tests/testData/testDataOptions.js

@@ -0,0 +1,60 @@
+export function addDefaultsToMockSelectedOption(root, optionCodeToAdd, optionCodesToRemove, unlessOptionCodes) {
+    let next = root.next;
+    if (next === undefined) {
+        if (optionCodeToAdd === undefined) {
+            return;
+        }
+        next = {};
+        root.next = next;
+    }
+    for (const oCode of unlessOptionCodes) {
+        if (next[oCode] !== undefined) {
+            return;
+        }
+    }
+    for (const oCode of optionCodesToRemove) {
+        delete next[oCode];
+    }
+    if (optionCodeToAdd === undefined) {
+        return;
+    }
+    next[optionCodeToAdd] = { code: optionCodeToAdd };
+}
+export const letterOptionCodeA = "optA";
+export const letterOptionCodeB = "optB";
+export const letterOptionCodeC = "optC";
+export const letterOptionCodeD = "optD";
+export const letterOptionCodeE = "optE";
+export const letterOptionCodeF = "optF";
+export const letterOptions = [
+    {
+        code: letterOptionCodeA,
+        description: "",
+    },
+    {
+        code: letterOptionCodeB,
+        description: "",
+    },
+    {
+        code: letterOptionCodeC,
+        description: "",
+    },
+    {
+        code: letterOptionCodeD,
+        description: "",
+    },
+    {
+        code: letterOptionCodeE,
+        description: "",
+    },
+    {
+        code: letterOptionCodeF,
+        description: "",
+    },
+];
+export const toggleOptionCodeOff = "optOff";
+export const toggleOptionCodeOn = "optOn";
+export const toggleOptions = [
+    { code: toggleOptionCodeOff, description: "" },
+    { code: toggleOptionCodeOn, description: "" },
+];

package/dist/tests/testData/testDataProductAggregatedPrice.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { CfgProduct } from "../../CfgProduct.js";
 import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptionCodeB, letterOptionCodeC, letterOptions, } from "./testDataOptions.js";
 const A = () => ({
     uuid: "A",
     unit: "m",
@@ -18,24 +19,12 @@ const A = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "optionA",
-                    description: "",
-                    additionalProductRefs: [
+                Object.assign(Object.assign({}, letterOptions[0]), { additionalProductRefs: [
                         { refKey: "C_0", catId: dummyCatId, partNumber: "C" },
                         { refKey: "B_0", catId: dummyCatId, partNumber: "B" },
-                    ],
-                },
-                {
-                    code: "optionB",
-                    description: "",
-                    additionalProductRefs: [{ refKey: "E", catId: dummyCatId, partNumber: "E" }],
-                },
-                {
-                    code: "optionC",
-                    description: "",
-                    additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }],
-                },
+                    ] }),
+                Object.assign(Object.assign({}, letterOptions[1]), { additionalProductRefs: [{ refKey: "E", catId: dummyCatId, partNumber: "E" }] }),
+                Object.assign(Object.assign({}, letterOptions[2]), { additionalProductRefs: [{ refKey: "D", catId: dummyCatId, partNumber: "D" }] }),
             ],
         },
     ],
@@ -51,8 +40,8 @@ const A = () => ({
                 {
                     code: "!~!",
                     next: {
-                        optionA: {
-                            code: "optionA",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
@@ -150,13 +139,13 @@ export const getTestProduct = (params) => __awaiter(void 0, void 0, void 0, func
     throw new Error("No such part");
 });
 export function getSelOptions(option) {
-    if (option === "optionB") {
+    if (option === letterOptionCodeB) {
         return [
             {
                 code: "!~!",
                 next: {
-                    optionB: {
-                        code: "optionB",
+                    [letterOptionCodeB]: {
+                        code: letterOptionCodeB,
                     },
                 },
             },
@@ -167,8 +156,8 @@ export function getSelOptions(option) {
             {
                 code: "!~!",
                 next: {
-                    optionC: {
-                        code: "optionC",
+                    [letterOptionCodeC]: {
+                        code: letterOptionCodeC,
                     },
                 },
             },

package/dist/tests/testData/testDataUpcharge.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { CfgProduct } from "../../CfgProduct.js";
 import { Collector } from "./collectorForTest.js";
 import { dummyCatId } from "./dummyProductForTest.js";
+import { letterOptionCodeA, letterOptions } from "./testDataOptions.js";
 const Prd = () => ({
     uuid: "Prd",
     unit: "m",
@@ -19,20 +20,9 @@ const Prd = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 0,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 0 }),
             ],
         },
         {
@@ -40,20 +30,9 @@ const Prd = () => ({
             description: "",
             numericOrder: false,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
             ],
         },
         {
@@ -62,20 +41,9 @@ const Prd = () => ({
             numericOrder: false,
             optional: true,
             options: [
-                {
-                    code: "A",
-                    description: "",
-                },
-                {
-                    code: "B",
-                    description: "",
-                    upcharge: undefined,
-                },
-                {
-                    code: "C",
-                    description: "",
-                    upcharge: 10,
-                },
+                letterOptions[0],
+                Object.assign(Object.assign({}, letterOptions[1]), { upcharge: undefined }),
+                Object.assign(Object.assign({}, letterOptions[2]), { upcharge: 10 }),
             ],
         },
     ],
@@ -91,24 +59,24 @@ const Prd = () => ({
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },
                 {
                     code: "!~!",
                     next: {
-                        A: {
-                            code: "A",
+                        [letterOptionCodeA]: {
+                            code: letterOptionCodeA,
                         },
                     },
                 },

package/dist/utilitiesCatalogueData.d.ts

@@ -1,4 +1,4 @@
-import { CatalogueParams, GetProductParams, Model, PartsData, Prices, ProductData, ProductResponse, SelectedOption, ValidateResponse } from "./CatalogueAPI.js";
+import { AdditionalProductRef, CatalogueParams, GetProductParams, MeasureParam, Model, Orientation, PartsData, Prices, ProductData, ProductResponse, SelectedOption, Transform, ValidateResponse, Vector } from "./CatalogueAPI.js";
 export declare const makeCatalogueKey: (cat: CatalogueParams) => string;
 export declare const makeProductKey: (cat: CatalogueParams, pKey: string) => string;
 export declare const makeSelOptionsKey: (options: SelectedOption[]) => string;
@@ -23,4 +23,10 @@ export declare function recursivelyGetPriceCodeValue(priceCodes: string[], price
 export declare function comparePricesObjects(prices1: Prices | undefined, prices2: Prices | undefined): boolean;
 export declare const decodeCatalogueParams: <T extends CatalogueParams>(params: T) => T;
 export declare const decodeProductParams: <T extends GetProductParams>(params: T) => T;
+export declare function isSameCatalogueParams(left: CatalogueParams, right: CatalogueParams): boolean;
+export declare function isSameVector(left: Vector, right: Vector): boolean;
+export declare function isSameOrientation(left: Orientation, right: Orientation): boolean;
+export declare function isSameAnchor(left: MeasureParam, right: MeasureParam): boolean;
+export declare function isSameTransform(left: Transform, right: Transform): boolean;
+export declare function isSameProductRef(left: AdditionalProductRef, right: AdditionalProductRef): boolean;
 //# sourceMappingURL=utilitiesCatalogueData.d.ts.map

package/dist/utilitiesCatalogueData.js

@@ -2,15 +2,14 @@ import { shallowCompareDictionaries } from "@configura/web-utilities";
 export const makeCatalogueKey = (cat) => `${cat.enterprise}-${cat.prdCat}-${cat.prdCatVersion}-${cat.priceList}-${cat.vendor}`;
 export const makeProductKey = (cat, pKey) => `${makeCatalogueKey(cat)}-${pKey}`;
 export const makeSelOptionsKey = (options) => options.reduce((p, option) => {
-    var _a;
-    const { code, numericValue, next } = option;
-    p += `_{${code}${numericValue === undefined ? "" : `_${numericValue.value}${(_a = numericValue.unit) !== null && _a !== void 0 ? _a : ""}`}`;
+    const { code, next } = option;
+    p += "_{" + code;
     if (next === undefined) {
         return p;
     }
     for (const key of Object.keys(next)) {
         const innerOption = next[key];
-        p += `_{${key}_${makeSelOptionsKey([innerOption])}_}`;
+        p += "_{" + key + "_" + makeSelOptionsKey([innerOption]) + "_}";
     }
     p += "_}";
     return p;
@@ -63,3 +62,105 @@ export const decodeProductParams = (params) => {
     const decoded = Object.assign(Object.assign({}, decodeCatalogueParams(params)), { partNumber: decodeURIComponent(params.partNumber) });
     return decoded;
 };
+export function isSameCatalogueParams(left, right) {
+    return (left.enterprise === right.enterprise &&
+        left.prdCat === right.prdCat &&
+        left.prdCatVersion === right.prdCatVersion &&
+        left.priceList === right.priceList &&
+        left.vendor === right.vendor);
+}
+export function isSameVector(left, right) {
+    return left.x === right.x && left.y === right.y && left.z === right.z;
+}
+export function isSameOrientation(left, right) {
+    return left.pitch === right.pitch && left.roll === right.roll && left.yaw === right.yaw;
+}
+export function isSameAnchor(left, right) {
+    var _a, _b;
+    if (left.code !== right.code) {
+        return false;
+    }
+    if (left.anchorPoint !== right.anchorPoint) {
+        return false;
+    }
+    const leftMeasurePriorities = (_a = left.measurePriority) !== null && _a !== void 0 ? _a : [];
+    const rightMeasurePriorities = (_b = right.measurePriority) !== null && _b !== void 0 ? _b : [];
+    if (leftMeasurePriorities.length !== rightMeasurePriorities.length) {
+        return false;
+    }
+    if (leftMeasurePriorities.some((p, i) => p.url !== rightMeasurePriorities[i].url)) {
+        return false;
+    }
+    return true;
+}
+export function isSameTransform(left, right) {
+    const leftTransformPos = left.pos;
+    const rightTransformPos = right.pos;
+    const leftTransformRot = left.rot;
+    const rightTransformRot = right.rot;
+    const leftTransformScale = left.scale;
+    const rightTransformScale = right.scale;
+    if ((leftTransformPos === undefined) !== (rightTransformPos === undefined)) {
+        return false;
+    }
+    if ((leftTransformRot === undefined) !== (rightTransformRot === undefined)) {
+        return false;
+    }
+    if ((leftTransformScale === undefined) !== (rightTransformScale === undefined)) {
+        return false;
+    }
+    if (leftTransformPos !== undefined &&
+        rightTransformPos !== undefined &&
+        !isSameVector(leftTransformPos, rightTransformPos)) {
+        return false;
+    }
+    if (leftTransformRot !== undefined &&
+        rightTransformRot !== undefined &&
+        !isSameOrientation(leftTransformRot, rightTransformRot)) {
+        return false;
+    }
+    if (leftTransformScale !== undefined &&
+        rightTransformScale !== undefined &&
+        !isSameVector(leftTransformScale, rightTransformScale)) {
+        return false;
+    }
+    return true;
+}
+export function isSameProductRef(left, right) {
+    if (left.refKey !== right.refKey) {
+        return false;
+    }
+    if (!isSameCatalogueParams(left.catId, right.catId)) {
+        return false;
+    }
+    if (left.partNumber !== right.partNumber) {
+        return false;
+    }
+    if (left.refDescription !== right.refDescription) {
+        return false;
+    }
+    const leftAnchor = left.anchor;
+    const rightAnchor = right.anchor;
+    if ((leftAnchor === undefined) !== (rightAnchor === undefined)) {
+        return false;
+    }
+    if (leftAnchor !== undefined &&
+        rightAnchor !== undefined &&
+        !isSameAnchor(leftAnchor, rightAnchor)) {
+        return false;
+    }
+    const leftTransform = left.transform;
+    const rightTransform = right.transform;
+    if ((leftTransform === undefined) !== (rightTransform === undefined)) {
+        return false;
+    }
+    if (leftTransform !== undefined &&
+        rightTransform !== undefined &&
+        !isSameTransform(leftTransform, rightTransform)) {
+        return false;
+    }
+    if (left.optional !== right.optional) {
+        return false;
+    }
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@configura/web-api",
-	"version": "1.6.0-iotest.2",
+	"version": "1.6.1-alpha.1",
 	"license": "Apache-2.0",
 	"type": "module",
 	"main": "dist/index.js",
@@ -23,7 +23,7 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@configura/web-utilities": "1.6.0-iotest.2"
+		"@configura/web-utilities": "^1.6.1-alpha.1"
 	},
-	"gitHead": "c03efb8cfe9fb28a83aaa19bbac09a30a7032e01"
+	"gitHead": "afaf1e342f0648246a1dcb6f7bc636d4d1979bec"
 }

package/dist/io/CfgHistoryManager.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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,
-});