@configura/web-api 2.2.0-alpha.1 → 2.2.0-alpha.3

package/dist/productConfiguration/utilitiesProductConfiguration.js

@@ -1,87 +1,89 @@
-import { someMatch } from "@configura/web-utilities";
-import { CfgFeature } from "./CfgFeature.js";
-import { CfgOption } from "./CfgOption.js";
-import { CfgProductConfiguration, } from "./CfgProductConfiguration.js";
-/**
- * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
- * currentFeatures if they can be found, otherwise makes new.
- */
-export function syncCfgFeatures(newFeatureRefs, currentFeatures, rawFeatures, parent, parentConfiguration, parentProduct, rootProduct) {
-    const usedRawFeatures = newFeatureRefs
-        .map((r) => r.code)
-        .map((c) => {
-        const rawFeature = rawFeatures.find((f) => c === f.code);
-        if (rawFeature === undefined) {
-            throw new Error(`Feature not found. Requested feature code: "${c}".`);
-        }
-        return rawFeature;
-    });
-    const hasDuplicateDescription = someMatch(usedRawFeatures, (l, r) => {
-        return l.description.toLowerCase() === r.description.toLowerCase();
-    });
-    const newFeatures = [];
-    for (const f of usedRawFeatures) {
-        const fCode = f.code;
-        const fDescription = f.description;
-        // It is possible in Cat Creator to add the same Feature twice
-        // to the root of a Product. This fills no apparent purpose,
-        // and in CET the seem to behave as if they were the same.
-        // Removing the duplicates causes sync issues where the server
-        // expects all copies, and hence we short circuit them here
-        // by letting them refer to the same object instead.
-        const twin = newFeatures.find((f) => f.code === fCode);
-        if (twin !== undefined) {
-            newFeatures.push(twin);
-            continue;
-        }
-        // Description based code helps when switching between
-        // products with similar feature-options tree and trying
-        // to retain made selections
-        const key = fDescription + (fDescription === "" || hasDuplicateDescription ? fCode : "");
-        const existingFeature = currentFeatures.find((cfgF) => cfgF.code === fCode);
-        if (existingFeature !== undefined) {
-            if (hasDuplicateDescription) {
-                // HasDuplicateDescription could mean the key need to be more specific compared
-                // to the one we already have, so then we set it. An old duplicate description
-                // key will cause no harm as it is guaranteed to be at least as specific as this.
-                // Not changing the key will make React not rerender, so we don't change.
-                existingFeature._internal.key = key;
-            }
-            newFeatures.push(existingFeature);
-            continue;
-        }
-        newFeatures.push(CfgFeature.make(f, rawFeatures, key, parent, parentConfiguration, parentProduct, rootProduct));
-    }
-    return newFeatures;
-}
-export function getMtrlPreview(mtrlApplications) {
-    if (mtrlApplications === undefined) {
-        return;
-    }
-    const first = mtrlApplications[0];
-    if (first === undefined) {
-        return;
-    }
-    return first.previewUrl;
-}
-/**
- * Recursively find all additional product references given a product configuration.
- * Only selected options are considered.
- */
-export function collectAdditionalProductRefs(parent) {
-    function c(parent) {
-        const result = [];
-        if (parent instanceof CfgOption && parent.selected) {
-            result.push(...(parent.rawOption.additionalProductRefs || []));
-        }
-        if (parent instanceof CfgProductConfiguration || parent.selected) {
-            for (const feature of parent.features) {
-                for (const option of feature.options) {
-                    result.push(...c(option));
-                }
-            }
-        }
-        return result;
-    }
-    return c(parent);
-}
+import { someMatch } from "@configura/web-utilities";
+import { CfgFeature } from "./CfgFeature.js";
+import { CfgOption } from "./CfgOption.js";
+import { CfgProductConfiguration, } from "./CfgProductConfiguration.js";
+/**
+ * Returns a new array of CfgFeatures that maps to the newFeatureRefs array. Uses CfgFeatures from
+ * currentFeatures if they can be found, otherwise makes new.
+ */
+export function syncCfgFeatures(newFeatureRefs, currentFeatures, rawFeatures, parent, parentConfiguration, parentProduct, rootProduct) {
+    const usedRawFeatures = newFeatureRefs
+        .map((r) => r.code)
+        .map((c) => {
+        const rawFeature = rawFeatures.find((f) => c === f.code);
+        if (rawFeature === undefined) {
+            throw new Error(`Feature not found. Requested feature code: "${c}".`);
+        }
+        return rawFeature;
+    });
+    const hasDuplicateDescription = parentProduct.settings.disableMatchOnDescription
+        ? true
+        : someMatch(usedRawFeatures, (l, r) => {
+            return l.description.toLowerCase() === r.description.toLowerCase();
+        });
+    const newFeatures = [];
+    for (const f of usedRawFeatures) {
+        const fCode = f.code;
+        const fDescription = f.description;
+        // It is possible in Cat Creator to add the same Feature twice
+        // to the root of a Product. This fills no apparent purpose,
+        // and in CET the seem to behave as if they were the same.
+        // Removing the duplicates causes sync issues where the server
+        // expects all copies, and hence we short circuit them here
+        // by letting them refer to the same object instead.
+        const twin = newFeatures.find((f) => f.code === fCode);
+        if (twin !== undefined) {
+            newFeatures.push(twin);
+            continue;
+        }
+        // Description based code helps when switching between
+        // products with similar feature-options tree and trying
+        // to retain made selections
+        const key = fDescription + (fDescription === "" || hasDuplicateDescription ? fCode : "");
+        const existingFeature = currentFeatures.find((cfgF) => cfgF.code === fCode);
+        if (existingFeature !== undefined) {
+            if (hasDuplicateDescription) {
+                // HasDuplicateDescription could mean the key need to be more specific compared
+                // to the one we already have, so then we set it. An old duplicate description
+                // key will cause no harm as it is guaranteed to be at least as specific as this.
+                // Not changing the key will make React not rerender, so we don't change.
+                existingFeature._internal.key = key;
+            }
+            newFeatures.push(existingFeature);
+            continue;
+        }
+        newFeatures.push(CfgFeature.make(f, rawFeatures, key, parent, parentConfiguration, parentProduct, rootProduct));
+    }
+    return newFeatures;
+}
+export function getMtrlPreview(mtrlApplications) {
+    if (mtrlApplications === undefined) {
+        return;
+    }
+    const first = mtrlApplications[0];
+    if (first === undefined) {
+        return;
+    }
+    return first.previewUrl;
+}
+/**
+ * Recursively find all additional product references given a product configuration.
+ * Only selected options are considered.
+ */
+export function collectAdditionalProductRefs(parent) {
+    function c(parent) {
+        const result = [];
+        if (parent instanceof CfgOption && parent.selected) {
+            result.push(...(parent.rawOption.additionalProductRefs || []));
+        }
+        if (parent instanceof CfgProductConfiguration || parent.selected) {
+            for (const feature of parent.features) {
+                for (const option of feature.options) {
+                    result.push(...c(option));
+                }
+            }
+        }
+        return result;
+    }
+    return c(parent);
+}

package/dist/productLoader.d.ts

@@ -1,34 +1,34 @@
-import { DtoProductParamsWithCidAndLang, DtoValidateRequest } from "./CatalogueAPI.js";
-import { CfgProductResponse, CfgValidateResponse } from "./utilitiesCatalogueData.js";
-export declare type GetProduct = (params: DtoProductParamsWithCidAndLang) => Promise<CfgProductResponse>;
-export declare type PostValidate = (params: DtoProductParamsWithCidAndLang, body: DtoValidateRequest) => Promise<CfgValidateResponse>;
-export declare type ProductLoader = {
-    getProduct: GetProduct;
-    postValidate: PostValidate;
-};
-/**
- * Wraps a getProduct function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. For this reason we recommend using this with caution.
- *
- * In our Example App we use it to cache the internal calls in additional products as in such a
- * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
- * four times.
- */
-export declare function wrapWithGetProductCache(getProduct: GetProduct): GetProduct;
-/**
- * Wraps a postValidate function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. We recommend you do not use this unless you are really, really sure what you are
- * doing.
- *
- * The SDK uses it for additional products to avoid validating for example the same table legs four
- * times at the same time. There we make sure the this cache only stays in scope for one user
- * interaction. No longer than the actions caused by a user clicking an option.
- */
-export declare function wrapWithPostValidateCache(postValidate: PostValidate): PostValidate;
-/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
-export declare function wrapWithCache(loader: ProductLoader): ProductLoader;
+import { DtoProductParamsWithCidAndLang, DtoValidateRequest } from "./CatalogueAPI.js";
+import { CfgProductResponse, CfgValidateResponse } from "./utilitiesCatalogueData.js";
+export declare type GetProduct = (params: DtoProductParamsWithCidAndLang) => Promise<CfgProductResponse>;
+export declare type PostValidate = (params: DtoProductParamsWithCidAndLang, body: DtoValidateRequest) => Promise<CfgValidateResponse>;
+export declare type ProductLoader = {
+    getProduct: GetProduct;
+    postValidate: PostValidate;
+};
+/**
+ * Wraps a getProduct function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. For this reason we recommend using this with caution.
+ *
+ * In our Example App we use it to cache the internal calls in additional products as in such a
+ * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
+ * four times.
+ */
+export declare function wrapWithGetProductCache(getProduct: GetProduct): GetProduct;
+/**
+ * Wraps a postValidate function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. We recommend you do not use this unless you are really, really sure what you are
+ * doing.
+ *
+ * The SDK uses it for additional products to avoid validating for example the same table legs four
+ * times at the same time. There we make sure the this cache only stays in scope for one user
+ * interaction. No longer than the actions caused by a user clicking an option.
+ */
+export declare function wrapWithPostValidateCache(postValidate: PostValidate): PostValidate;
+/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
+export declare function wrapWithCache(loader: ProductLoader): ProductLoader;
 //# sourceMappingURL=productLoader.d.ts.map

package/dist/productLoader.js

@@ -1,49 +1,49 @@
-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());
-    });
-};
-import { PromiseCache } from "@configura/web-utilities";
-import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js";
-/**
- * Wraps a getProduct function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. For this reason we recommend using this with caution.
- *
- * In our Example App we use it to cache the internal calls in additional products as in such a
- * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
- * four times.
- */
-export function wrapWithGetProductCache(getProduct) {
-    const cache = new PromiseCache();
-    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params), () => getProduct(params)); });
-}
-/**
- * Wraps a postValidate function so that it caches for the time it lives.
- *
- * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
- * indefinitely. We recommend you do not use this unless you are really, really sure what you are
- * doing.
- *
- * The SDK uses it for additional products to avoid validating for example the same table legs four
- * times at the same time. There we make sure the this cache only stays in scope for one user
- * interaction. No longer than the actions caused by a user clicking an option.
- */
-export function wrapWithPostValidateCache(postValidate) {
-    const cache = new PromiseCache();
-    return (params, body) => __awaiter(this, void 0, void 0, function* () {
-        return cache.get(`${makeProductKey(params)}-${makeSelOptionsKey(body.selOptions)}-${body.knownFeatureCodes.join(",")}`, () => postValidate(params, body));
-    });
-}
-/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
-export function wrapWithCache(loader) {
-    return {
-        getProduct: wrapWithGetProductCache(loader.getProduct.bind(loader)),
-        postValidate: wrapWithPostValidateCache(loader.postValidate.bind(loader)),
-    };
-}
+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());
+    });
+};
+import { PromiseCache } from "@configura/web-utilities";
+import { makeProductKey, makeSelOptionsKey, } from "./utilitiesCatalogueData.js";
+/**
+ * Wraps a getProduct function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. For this reason we recommend using this with caution.
+ *
+ * In our Example App we use it to cache the internal calls in additional products as in such a
+ * product you tend to frequently get calls to same sub-product. Such as loading the same table leg
+ * four times.
+ */
+export function wrapWithGetProductCache(getProduct) {
+    const cache = new PromiseCache();
+    return (params) => __awaiter(this, void 0, void 0, function* () { return cache.get(makeProductKey(params), () => getProduct(params)); });
+}
+/**
+ * Wraps a postValidate function so that it caches for the time it lives.
+ *
+ * It has no cache invalidation or timeouts, so whatever ends up in the cache stays there
+ * indefinitely. We recommend you do not use this unless you are really, really sure what you are
+ * doing.
+ *
+ * The SDK uses it for additional products to avoid validating for example the same table legs four
+ * times at the same time. There we make sure the this cache only stays in scope for one user
+ * interaction. No longer than the actions caused by a user clicking an option.
+ */
+export function wrapWithPostValidateCache(postValidate) {
+    const cache = new PromiseCache();
+    return (params, body) => __awaiter(this, void 0, void 0, function* () {
+        return cache.get(`${makeProductKey(params)}-${makeSelOptionsKey(body.selOptions)}-${body.knownFeatureCodes.join(",")}`, () => postValidate(params, body));
+    });
+}
+/** Does both wrapWithGetProductCache and wrapWithPostValidateCache. */
+export function wrapWithCache(loader) {
+    return {
+        getProduct: wrapWithGetProductCache(loader.getProduct.bind(loader)),
+        postValidate: wrapWithPostValidateCache(loader.postValidate.bind(loader)),
+    };
+}

package/dist/syncGroups/SyncGroupsApplyMode.d.ts

@@ -1,21 +1,21 @@
-/**
- * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
- * run of rootProductOntoSyncState.
- *
- * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
- * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
- *
- * The downside of this is that is not exactly how CET (the desktop software) works. CET will
- * instead apply Features to the SyncState as soon as it gets the chance.
- *
- * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
- * calls, increasing delay and cost.
- *
- * Strict is the safer option of the two, but we still recommend trying out Fast since it should
- * work fine in most cases.
- */
-export declare enum SyncGroupsApplyMode {
-    Strict = "Strict",
-    Fast = "Fast"
-}
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState.
+ *
+ * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
+ * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
+ *
+ * The downside of this is that is not exactly how CET (the desktop software) works. CET will
+ * instead apply Features to the SyncState as soon as it gets the chance.
+ *
+ * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
+ * calls, increasing delay and cost.
+ *
+ * Strict is the safer option of the two, but we still recommend trying out Fast since it should
+ * work fine in most cases.
+ */
+export declare enum SyncGroupsApplyMode {
+    Strict = "Strict",
+    Fast = "Fast"
+}
 //# sourceMappingURL=SyncGroupsApplyMode.d.ts.map

package/dist/syncGroups/SyncGroupsApplyMode.js

@@ -1,21 +1,21 @@
-/**
- * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
- * run of rootProductOntoSyncState.
- *
- * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
- * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
- *
- * The downside of this is that is not exactly how CET (the desktop software) works. CET will
- * instead apply Features to the SyncState as soon as it gets the chance.
- *
- * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
- * calls, increasing delay and cost.
- *
- * Strict is the safer option of the two, but we still recommend trying out Fast since it should
- * work fine in most cases.
- */
-export var SyncGroupsApplyMode;
-(function (SyncGroupsApplyMode) {
-    SyncGroupsApplyMode["Strict"] = "Strict";
-    SyncGroupsApplyMode["Fast"] = "Fast";
-})(SyncGroupsApplyMode || (SyncGroupsApplyMode = {}));
+/**
+ * The SyncGroupsApplyMode controls how many SyncGroups can be updated in the SyncState for one
+ * run of rootProductOntoSyncState.
+ *
+ * "Fast" will update any SyncGroup that should be updated before running syncStateOntoRootProduct
+ * This way several SyncGroups can be applied in one go before sending the validation calls to the * server, making the whole process faster.
+ *
+ * The downside of this is that is not exactly how CET (the desktop software) works. CET will
+ * instead apply Features to the SyncState as soon as it gets the chance.
+ *
+ * "Strict" tries to behave exactly as CET. This will potentially generate a lot more validate
+ * calls, increasing delay and cost.
+ *
+ * Strict is the safer option of the two, but we still recommend trying out Fast since it should
+ * work fine in most cases.
+ */
+export var SyncGroupsApplyMode;
+(function (SyncGroupsApplyMode) {
+    SyncGroupsApplyMode["Strict"] = "Strict";
+    SyncGroupsApplyMode["Fast"] = "Fast";
+})(SyncGroupsApplyMode || (SyncGroupsApplyMode = {}));

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -1,48 +1,48 @@
-import { AggregatedLoadingObservable } from "@configura/web-utilities";
-import { DtoSyncGroupState } from "../CatalogueAPI.js";
-import { _CfgProductInternal } from "../CfgProduct.js";
-import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
-import { ProductLoader } from "../productLoader.js";
-import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
-import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
-export declare type SyncCode = string;
-export declare type OptionCode = string;
-/**
- * Is used to apply the SyncGroups functionality on the Configuration and the other way around.
- * It also keeps the SyncState.
- */
-export declare class SyncGroupsHandler {
-    private _syncState;
-    readonly updateMode: SyncGroupsApplyMode;
-    private readonly _loadingObservable;
-    private _currentTransaction;
-    /**
-     * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
-     */
-    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable, initial?: DtoSyncGroupState, verboseLogging?: boolean): SyncGroupsHandler;
-    private constructor();
-    /** Please note that clones will use the same loadingObservable as their source. */
-    clone(): SyncGroupsHandler;
-    getCompactSyncGroupState(): DtoSyncGroupState;
-    /** Overwrites the sync state */
-    setCompactSyncGroupState(s: DtoSyncGroupState): void;
-    get verboseLogging(): boolean;
-    set verboseLogging(v: boolean);
-    /**
-     * Used to initially apply the sync state onto a new product so that it is "in sync"
-     * and to reapply the sync state when an optional additional product is selected.
-     */
-    init(product: _CfgProductInternal, productLoader: ProductLoader): Promise<void>;
-    /**
-     * Used when an Option is selected or deselected to apply all consequences of the sync groups.
-     * Can cause multiple extra validation calls to the server.
-     */
-    selectOption(product: _CfgProductInternal, option: _CfgOptionInternal, on: boolean, productLoader: ProductLoader): Promise<boolean>;
-    private _pending;
-    private setPending;
-    get pending(): _CfgOptionInternal | undefined;
-    private newTransaction;
-    private closeTransaction;
-    commitTransaction(transaction: SyncGroupsTransaction): Promise<void>;
-}
+import { AggregatedLoadingObservable } from "@configura/web-utilities";
+import { DtoSyncGroupState } from "../CatalogueAPI.js";
+import { _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { ProductLoader } from "../productLoader.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
+export declare type SyncCode = string;
+export declare type OptionCode = string;
+/**
+ * Is used to apply the SyncGroups functionality on the Configuration and the other way around.
+ * It also keeps the SyncState.
+ */
+export declare class SyncGroupsHandler {
+    private _syncState;
+    readonly updateMode: SyncGroupsApplyMode;
+    private readonly _loadingObservable;
+    private _currentTransaction;
+    /**
+     * @param verboseLogging Set to true to get verbose sync state changes logged to the console.
+     */
+    static make(updateMode?: SyncGroupsApplyMode, loadingObservable?: AggregatedLoadingObservable, initial?: DtoSyncGroupState, verboseLogging?: boolean): SyncGroupsHandler;
+    private constructor();
+    /** Please note that clones will use the same loadingObservable as their source. */
+    clone(): SyncGroupsHandler;
+    getCompactSyncGroupState(): DtoSyncGroupState;
+    /** Overwrites the sync state */
+    setCompactSyncGroupState(s: DtoSyncGroupState): void;
+    get verboseLogging(): boolean;
+    set verboseLogging(v: boolean);
+    /**
+     * Used to initially apply the sync state onto a new product so that it is "in sync"
+     * and to reapply the sync state when an optional additional product is selected.
+     */
+    init(product: _CfgProductInternal, productLoader: ProductLoader): Promise<void>;
+    /**
+     * Used when an Option is selected or deselected to apply all consequences of the sync groups.
+     * Can cause multiple extra validation calls to the server.
+     */
+    selectOption(product: _CfgProductInternal, option: _CfgOptionInternal, on: boolean, productLoader: ProductLoader): Promise<boolean>;
+    private _pending;
+    private setPending;
+    get pending(): _CfgOptionInternal | undefined;
+    private newTransaction;
+    private closeTransaction;
+    commitTransaction(transaction: SyncGroupsTransaction): Promise<void>;
+}
 //# sourceMappingURL=SyncGroupsHandler.d.ts.map