@configura/web-api 1.4.0 → 1.6.0-alpha.0

package/dist/syncGroups/SyncGroupsHandler.d.ts

@@ -0,0 +1,30 @@
+import { CfgPath, _CfgProductInternal } from "../CfgProduct.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 _currentTransaction;
+    static make(updateMode?: SyncGroupsApplyMode): SyncGroupsHandler;
+    private constructor();
+    clone(): SyncGroupsHandler;
+    /**
+     * Used to initially apply the sync state onto a new product so that it is "in sync"
+     */
+    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, optionPath: CfgPath, on: boolean, productLoader: ProductLoader): Promise<boolean>;
+    newTransaction(product: _CfgProductInternal, productLoader: ProductLoader, assumeNoStartProductState: boolean): Promise<SyncGroupsTransaction>;
+    applyTransaction(transaction: SyncGroupsTransaction): Promise<void>;
+}
+//# sourceMappingURL=SyncGroupsHandler.d.ts.map

package/dist/syncGroups/SyncGroupsHandler.js

@@ -0,0 +1,71 @@
+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 { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { SyncGroupsState } from "./SyncGroupsState.js";
+import { SyncGroupsTransaction } from "./SyncGroupsTransaction.js";
+/**
+ * Is used to apply the SyncGroups functionality on the Configuration and the other
+ * way around. It also keeps the SyncState.
+ */
+export class SyncGroupsHandler {
+    constructor(_syncState, updateMode) {
+        this._syncState = _syncState;
+        this.updateMode = updateMode;
+    }
+    static make(updateMode = SyncGroupsApplyMode.Fast) {
+        return new SyncGroupsHandler(new SyncGroupsState(), updateMode);
+    }
+    clone() {
+        return new SyncGroupsHandler(this._syncState.clone(), this.updateMode);
+    }
+    /**
+     * Used to initially apply the sync state onto a new product so that it is "in sync"
+     */
+    init(product, productLoader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const transaction = yield this.newTransaction(product, productLoader, true);
+            yield transaction.init();
+            yield this.applyTransaction(transaction);
+        });
+    }
+    /**
+     * 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, optionPath, on, productLoader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            //todo: should we guarantee that it will use root? Tricky...
+            const transaction = yield this.newTransaction(product, productLoader, false);
+            const change = yield transaction.selectOption(optionPath, on);
+            // We always apply. The change-result above only tells if the configuration
+            // has changed. The SyncState may also have changed.
+            yield this.applyTransaction(transaction);
+            return change;
+        });
+    }
+    newTransaction(product, productLoader, assumeNoStartProductState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._currentTransaction !== undefined) {
+                this._currentTransaction.abort();
+            }
+            this._currentTransaction = yield SyncGroupsTransaction.make(this._syncState, this.updateMode, product, productLoader, assumeNoStartProductState);
+            return this._currentTransaction;
+        });
+    }
+    applyTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (transaction.isAborted) {
+                return;
+            }
+            this._syncState.setFrom(transaction.syncState);
+            yield transaction.original.copyFrom(transaction.target, false, transaction.productLoader);
+        });
+    }
+}

package/dist/syncGroups/SyncGroupsState.d.ts

@@ -0,0 +1,20 @@
+import { OptionCode, SyncCode } from "./SyncGroupsHandler.js";
+/**
+ * Is used to keep track of the current value of the SyncGroups. Is fully separated between
+ * SelectOne and SelectMany as Features of the two types are synced separately.
+ */
+export declare class SyncGroupsState {
+    readonly _selectOne: Map<SyncCode, OptionCode>;
+    readonly _selectMany: Map<SyncCode, Map<OptionCode, boolean>>;
+    clone(): SyncGroupsState;
+    /**
+     * Replaces the current state
+     */
+    setFrom(other: SyncGroupsState): void;
+    setForSelectOne(syncCode: SyncCode, optionCode: OptionCode): void;
+    setForSelectMany(syncCode: SyncCode, optionCode: OptionCode, selected: boolean): void;
+    getForSelectOne(syncCode: SyncCode): OptionCode | undefined;
+    getForSelectMany(syncCode: SyncCode, optionCode: OptionCode): boolean | undefined;
+    logDebug(): void;
+}
+//# sourceMappingURL=SyncGroupsState.d.ts.map

package/dist/syncGroups/SyncGroupsState.js

@@ -0,0 +1,61 @@
+/**
+ * Is used to keep track of the current value of the SyncGroups. Is fully separated between
+ * SelectOne and SelectMany as Features of the two types are synced separately.
+ */
+export class SyncGroupsState {
+    constructor() {
+        this._selectOne = new Map();
+        this._selectMany = new Map();
+    }
+    clone() {
+        const result = new SyncGroupsState();
+        result.setFrom(this);
+        return result;
+    }
+    /**
+     * Replaces the current state
+     */
+    setFrom(other) {
+        this._selectOne.clear();
+        this._selectMany.clear();
+        for (const [k, v] of other._selectOne) {
+            this._selectOne.set(k, v);
+        }
+        for (const [sourceSyncCode, sourceOptionToSelected] of other._selectMany) {
+            const targetOptionToSelected = new Map();
+            for (const [sourceOptionCode, sourceIsSelected] of sourceOptionToSelected) {
+                targetOptionToSelected.set(sourceOptionCode, sourceIsSelected);
+            }
+            this._selectMany.set(sourceSyncCode, targetOptionToSelected);
+        }
+    }
+    setForSelectOne(syncCode, optionCode) {
+        this._selectOne.set(syncCode, optionCode);
+        this.logDebug();
+    }
+    setForSelectMany(syncCode, optionCode, selected) {
+        let forSyncCode = this._selectMany.get(syncCode);
+        if (forSyncCode === undefined) {
+            forSyncCode = new Map();
+            this._selectMany.set(syncCode, forSyncCode);
+        }
+        forSyncCode.set(optionCode, selected);
+        this.logDebug();
+    }
+    getForSelectOne(syncCode) {
+        return this._selectOne.get(syncCode);
+    }
+    getForSelectMany(syncCode, optionCode) {
+        var _a;
+        return (_a = this._selectMany.get(syncCode)) === null || _a === void 0 ? void 0 : _a.get(optionCode);
+    }
+    logDebug() {
+        console.table(Array.from(this._selectOne.entries()));
+        console.table(Array.from(this._selectMany.entries()).reduce((a, [groupCode, optionCodeToSelected]) => {
+            for (const [optionCode, selected] of optionCodeToSelected) {
+                a.push([groupCode, optionCode, selected]);
+            }
+            return a;
+        }, []));
+    }
+}

package/dist/syncGroups/SyncGroupsTransaction.d.ts

@@ -0,0 +1,50 @@
+import { CfgPath, _CfgProductInternal } from "../CfgProduct.js";
+import { _CfgFeatureInternal } from "../productConfiguration/CfgFeature.js";
+import { _CfgOptionInternal } from "../productConfiguration/CfgOption.js";
+import { ProductLoader } from "../productLoader.js";
+import { SyncGroupsApplyMode } from "./SyncGroupsApplyMode.js";
+import { OptionCode, SyncCode } from "./SyncGroupsHandler.js";
+import { SyncGroupsState } from "./SyncGroupsState.js";
+/**
+ * A transaction is normally limited to one user interaction. Like opening a product or
+ * selecting an option. This object is used to keep data for one transaction. In particular
+ * what Features and what SyncGroups have been affected in the transaction. This is a means
+ * to eliminate the risk of infinite loops.
+ */
+export declare class SyncGroupsTransaction {
+    readonly syncState: SyncGroupsState;
+    readonly updateMode: SyncGroupsApplyMode;
+    readonly productLoader: ProductLoader;
+    readonly original: _CfgProductInternal;
+    readonly target: _CfgProductInternal;
+    readonly initial: _CfgProductInternal | undefined;
+    static make(syncState: SyncGroupsState, updateMode: SyncGroupsApplyMode, product: _CfgProductInternal, productLoader: ProductLoader, assumeNoStartState: boolean): Promise<SyncGroupsTransaction>;
+    /**
+     *
+     * @param syncState A clone of the original syncState. Replaces the original syncState if nothing fails and the transaction doesn't get aborted
+     * @param updateMode
+     * @param productLoader
+     * @param original The product instance that this transaction will be applied on provided nothing fails and the transaction doesn't get aborted
+     * @param target A clone of the original product used to apply the configuration changes to
+     * @param initial A clone of the original product used to track what the original state was. As a safe measure we do not use originalProduct for this, as it might be changed by someone else
+     */
+    private constructor();
+    private _aborted;
+    private affectedSelectOneFeatures;
+    private affectedSelectManyOptions;
+    private affectedSelectOneSyncGroups;
+    private affectedSelectManySyncGroupsAndOptions;
+    get isAborted(): boolean;
+    abort(): void;
+    init(): Promise<boolean>;
+    selectOption(optionPath: CfgPath, on: boolean): Promise<boolean>;
+    addSelectOneFeatureAffected(feature: _CfgFeatureInternal): void;
+    addSelectManyOptionAffected(option: _CfgOptionInternal): void;
+    hasSelectOneFeatureBeenAffected(feature: _CfgFeatureInternal): boolean;
+    hasSelectManyOptionBeenAffected(option: _CfgOptionInternal): boolean;
+    addSyncGroupAffectedForSelectOne(syncCode: SyncCode): void;
+    addSyncGroupAffectedForSelectMany(syncCode: SyncCode, optionCode: OptionCode): void;
+    isSyncGroupAffectedForSelectOne(syncCode: SyncCode): boolean;
+    isSyncGroupAffectedForSelectMany(syncCode: SyncCode, optionCode: OptionCode): boolean;
+}
+//# sourceMappingURL=SyncGroupsTransaction.d.ts.map

package/dist/syncGroups/SyncGroupsTransaction.js

@@ -0,0 +1,106 @@
+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 { SelectionType } from "../productConfiguration/CfgFeature.js";
+import { SyncGroupsApplier } from "./SyncGroupsApplier.js";
+/**
+ * A transaction is normally limited to one user interaction. Like opening a product or
+ * selecting an option. This object is used to keep data for one transaction. In particular
+ * what Features and what SyncGroups have been affected in the transaction. This is a means
+ * to eliminate the risk of infinite loops.
+ */
+export class SyncGroupsTransaction {
+    /**
+     *
+     * @param syncState A clone of the original syncState. Replaces the original syncState if nothing fails and the transaction doesn't get aborted
+     * @param updateMode
+     * @param productLoader
+     * @param original The product instance that this transaction will be applied on provided nothing fails and the transaction doesn't get aborted
+     * @param target A clone of the original product used to apply the configuration changes to
+     * @param initial A clone of the original product used to track what the original state was. As a safe measure we do not use originalProduct for this, as it might be changed by someone else
+     */
+    constructor(syncState, updateMode, productLoader, original, target, initial) {
+        this.syncState = syncState;
+        this.updateMode = updateMode;
+        this.productLoader = productLoader;
+        this.original = original;
+        this.target = target;
+        this.initial = initial;
+        this._aborted = false;
+        this.affectedSelectOneFeatures = new Set();
+        this.affectedSelectManyOptions = new Set();
+        this.affectedSelectOneSyncGroups = new Set();
+        this.affectedSelectManySyncGroupsAndOptions = new Map();
+    }
+    static make(syncState, updateMode, product, productLoader, assumeNoStartState) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const t = new this(syncState.clone(), updateMode, productLoader, product, yield product.clone(), assumeNoStartState ? undefined : yield product.clone());
+            return t;
+        });
+    }
+    get isAborted() {
+        return this._aborted;
+    }
+    abort() {
+        this._aborted = true;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield SyncGroupsApplier.init(this);
+        });
+    }
+    selectOption(optionPath, on) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetOption = this.target.getOptionFromPath(optionPath);
+            return yield SyncGroupsApplier.selectOption(this, targetOption, on);
+        });
+    }
+    addSelectOneFeatureAffected(feature) {
+        if (feature.selectionType !== SelectionType.SelectOne) {
+            throw new Error("Can only be used for SelectOne Feature");
+        }
+        this.affectedSelectOneFeatures.add(feature);
+    }
+    addSelectManyOptionAffected(option) {
+        if (option.parent.selectionType !== SelectionType.SelectMany) {
+            throw new Error("Can only be used for option in SelectMany Feature");
+        }
+        this.affectedSelectManyOptions.add(option);
+    }
+    hasSelectOneFeatureBeenAffected(feature) {
+        if (feature.selectionType !== SelectionType.SelectOne) {
+            throw new Error("Can only be used for SelectOne Feature");
+        }
+        return this.affectedSelectOneFeatures.has(feature);
+    }
+    hasSelectManyOptionBeenAffected(option) {
+        if (option.parent.selectionType !== SelectionType.SelectMany) {
+            throw new Error("Can only be used for option in SelectMany Feature");
+        }
+        return this.affectedSelectManyOptions.has(option);
+    }
+    addSyncGroupAffectedForSelectOne(syncCode) {
+        this.affectedSelectOneSyncGroups.add(syncCode);
+    }
+    addSyncGroupAffectedForSelectMany(syncCode, optionCode) {
+        let forSyncCode = this.affectedSelectManySyncGroupsAndOptions.get(syncCode);
+        if (forSyncCode === undefined) {
+            forSyncCode = new Set();
+            this.affectedSelectManySyncGroupsAndOptions.set(syncCode, forSyncCode);
+        }
+        forSyncCode.add(optionCode);
+    }
+    isSyncGroupAffectedForSelectOne(syncCode) {
+        return this.affectedSelectOneSyncGroups.has(syncCode);
+    }
+    isSyncGroupAffectedForSelectMany(syncCode, optionCode) {
+        var _a;
+        return ((_a = this.affectedSelectManySyncGroupsAndOptions.get(syncCode)) === null || _a === void 0 ? void 0 : _a.has(optionCode)) === true;
+    }
+}

package/dist/tasks/TaskHandler.d.ts

@@ -0,0 +1,79 @@
+import { Observable, SingleArgCallback } from "@configura/web-utilities";
+import { AdditionalProductConfiguration, CatalogueAPI, ExportStatus, ExportStatusStatus, PostExportParams, PostRenderParams, RenderStatus, RenderStatusStatus, TargetCameraArgs } from "../CatalogueAPI.js";
+import { CfgProduct } from "../CfgProduct.js";
+import { RenderOrExportFormat } from "./formats.js";
+export declare type TasksChangeNotification = {
+    freshRef: TaskHandler;
+};
+export declare type RenderTaskParams = {
+    targetCameraArgs?: TargetCameraArgs;
+    width: number;
+    height: number;
+};
+export declare type ProductParams = PostRenderParams | PostExportParams;
+export declare class _TaskHandlerInternal {
+    api: CatalogueAPI;
+    readonly changeObservable: Observable<TasksChangeNotification>;
+    readonly tasks: Task<RenderOrExportFormat>[];
+    constructor(api: CatalogueAPI);
+    _notifyAllOfChange: () => Promise<void>;
+    destroy: () => void;
+    get hasExport(): boolean;
+    get hasRender(): boolean;
+    get availableFormats(): RenderOrExportFormat[];
+    start: (format: RenderOrExportFormat, product: CfgProduct, renderParams: RenderTaskParams | undefined, getPreviewUrl: (() => Promise<string>) | undefined) => Promise<void>;
+    addTask(task: Task<RenderOrExportFormat>): void;
+    removeTask(task: Task<RenderOrExportFormat>): void;
+}
+export declare class TaskHandler {
+    private readonly _internal;
+    static make(api: CatalogueAPI): TaskHandler;
+    /**
+     * Makes an object wrapping the passed object. This is not a clone method,
+     * it is a method to make a new outer reference. Like a shallow copy.
+     * We use this to help frameworks that are build around using equals to detect change.
+     */
+    static _makeNewRefFrom(internal: _TaskHandlerInternal): TaskHandler;
+    private constructor();
+    destroy: () => void;
+    get tasks(): Task<RenderOrExportFormat>[];
+    get hasExport(): boolean;
+    get hasRender(): boolean;
+    get availableFormats(): RenderOrExportFormat[];
+    start: (format: RenderOrExportFormat, product: CfgProduct, renderParams?: RenderTaskParams | undefined, getPreviewUrl?: (() => Promise<string>) | undefined) => Promise<void>;
+    listenForChange: (l: SingleArgCallback<TasksChangeNotification>) => void;
+    stopListenForChange: (l: SingleArgCallback<TasksChangeNotification>) => void;
+}
+declare type TaskStatus = RenderStatusStatus | ExportStatusStatus | "abandoned";
+export declare abstract class Task<F extends RenderOrExportFormat> {
+    protected readonly taskHandler: _TaskHandlerInternal;
+    readonly format: F;
+    private _timerId;
+    protected constructor(taskHandler: _TaskHandlerInternal, format: F, product: CfgProduct, getPreviewUrl: (() => Promise<string>) | undefined);
+    protected abstract postInit(): Promise<RenderStatus | ExportStatus>;
+    protected abstract pollStatus(): Promise<RenderStatus | ExportStatus>;
+    protected _productParams: ProductParams;
+    protected _apiSelection: AdditionalProductConfiguration;
+    private _status;
+    private _uuid;
+    private _created;
+    private _modified;
+    private _url;
+    private _previewUrl;
+    private setStatus;
+    get status(): TaskStatus;
+    get uuid(): string;
+    get created(): string;
+    get modified(): string;
+    get url(): string | undefined;
+    get previewUrl(): string | undefined;
+    private _start;
+    protected startAndRegister: () => Promise<void>;
+    restart: () => Promise<void>;
+    private scheduleRefresh;
+    private refresh;
+    private stop;
+    abort: () => void;
+}
+export {};
+//# sourceMappingURL=TaskHandler.d.ts.map