@configura/web-api 2.0.0-alpha.20 → 2.0.0-alpha.21

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)}`, () => 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,44 +1,48 @@
-import { AggregatedLoadingObservable } from "@configura/web-utilities";
-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, verboseLogging?: boolean): SyncGroupsHandler;
-    private constructor();
-    /** Please note that clones will use the same loadingObservable as their source. */
-    clone(): SyncGroupsHandler;
-    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