@configura/web-api 1.4.0-alpha.4 → 1.5.0

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, params.partNumber), () => 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, params.partNumber)}-${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, params.partNumber), () => 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, params.partNumber)}-${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)),
+    };
+}

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

package/dist/tasks/TaskHandler.js

@@ -0,0 +1,265 @@
+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 { Observable } from "@configura/web-utilities";
+import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
+import { isExportFormat, isRenderFormat } from "./formats.js";
+const productToParams = (product) => (Object.assign(Object.assign({ lang: product.lang }, product.catId), { partNumber: product.partNumber }));
+export class _TaskHandlerInternal {
+    constructor(api) {
+        this.api = api;
+        this.changeObservable = new Observable();
+        this.tasks = [];
+        this._notifyAllOfChange = () => __awaiter(this, void 0, void 0, function* () {
+            const freshRef = TaskHandler._makeNewRefFrom(this);
+            this.changeObservable.notifyAll({ freshRef });
+        });
+        this.destroy = () => {
+            this.changeObservable.stopAllListen();
+            for (const task of this.tasks) {
+                task.abort();
+            }
+        };
+        this.start = (format, product, renderParams, getPreviewUrl) => __awaiter(this, void 0, void 0, function* () {
+            if (isRenderFormat(format)) {
+                if (!this.hasRender) {
+                    throw new Error("Render has not been activated for this Catalogue");
+                }
+                if (renderParams === undefined) {
+                    throw new Error("renderParams must be set for render");
+                }
+                yield TaskRender.make(this, format, product, renderParams, getPreviewUrl);
+                return;
+            }
+            if (isExportFormat(format)) {
+                if (!this.hasExport) {
+                    throw new Error("Export has not been activated for this Catalogue");
+                }
+                yield TaskExport.make(this, format, product, getPreviewUrl);
+                return;
+            }
+            throw new Error("Unknown export format");
+        });
+    }
+    get hasExport() {
+        return this.api.hasFeature("export");
+    }
+    get hasRender() {
+        return this.api.hasFeature("render");
+    }
+    get availableFormats() {
+        const result = [];
+        if (this.hasExport) {
+            result.push(...exportFormatNames);
+        }
+        if (this.hasRender) {
+            result.push(...renderFormatNames);
+        }
+        return result;
+    }
+    addTask(task) {
+        this.tasks.push(task);
+        this._notifyAllOfChange();
+    }
+    removeTask(task) {
+        const i = this.tasks.indexOf(task);
+        this.tasks.splice(i, 1);
+        this._notifyAllOfChange();
+    }
+}
+export class TaskHandler {
+    constructor(_internal) {
+        this._internal = _internal;
+        this.destroy = () => this._internal.destroy();
+        this.start = (format, product, renderParams, getPreviewUrl) => __awaiter(this, void 0, void 0, function* () { return this._internal.start(format, product, renderParams, getPreviewUrl); });
+        this.listenForChange = (l) => this._internal.changeObservable.listen(l);
+        this.stopListenForChange = (l) => this._internal.changeObservable.stopListen(l);
+    }
+    static make(api) {
+        return new this(new _TaskHandlerInternal(api));
+    }
+    /**
+     * 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) {
+        return new this(internal);
+    }
+    get tasks() {
+        return this._internal.tasks;
+    }
+    get hasExport() {
+        return this._internal.hasExport;
+    }
+    get hasRender() {
+        return this._internal.hasRender;
+    }
+    get availableFormats() {
+        return this._internal.availableFormats;
+    }
+}
+export class Task {
+    constructor(taskHandler, format, product, getPreviewUrl) {
+        this.taskHandler = taskHandler;
+        this.format = format;
+        this._status = "pending";
+        this._start = () => __awaiter(this, void 0, void 0, function* () {
+            const result = yield this.postInit();
+            this._uuid = result.uuid;
+            this._created = result.created;
+            this._modified = result.modified;
+            this.setStatus(result.status);
+            this.scheduleRefresh();
+        });
+        this.startAndRegister = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this._start();
+                this.taskHandler.addTask(this);
+            }
+            catch (e) {
+                this.setStatus("failed");
+                console.error(e);
+            }
+        });
+        this.restart = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.stop();
+                this.setStatus("pending");
+                yield this._start();
+            }
+            catch (e) {
+                this.setStatus("failed");
+                console.error(e);
+            }
+        });
+        this.scheduleRefresh = () => {
+            this._timerId = setTimeout(this.refresh, 1000);
+        };
+        this.refresh = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.pollStatus();
+                this._modified = result.modified;
+                const status = result.status;
+                switch (status) {
+                    case "finished":
+                        const url = result.url;
+                        if (!url) {
+                            throw new Error("No URL from finished task");
+                        }
+                        this._url = url;
+                        break;
+                    case "failed":
+                        break;
+                    case "running":
+                    case "pending":
+                        this.scheduleRefresh();
+                        break;
+                }
+                this.setStatus(status);
+            }
+            catch (e) {
+                this.setStatus("failed");
+                console.error(e);
+            }
+        });
+        this.abort = () => {
+            this._status = "abandoned";
+            this.stop();
+            this.taskHandler.removeTask(this);
+        };
+        this._productParams = productToParams(product);
+        this._apiSelection = product.getApiSelection();
+        if (getPreviewUrl !== undefined) {
+            getPreviewUrl().then((dataUrl) => {
+                this._previewUrl = dataUrl;
+                this.taskHandler._notifyAllOfChange();
+            });
+        }
+    }
+    setStatus(status) {
+        const isChange = this._status !== status;
+        this._status = status;
+        if (isChange) {
+            this.taskHandler._notifyAllOfChange();
+        }
+    }
+    get status() {
+        return this._status;
+    }
+    get uuid() {
+        if (this._uuid === undefined) {
+            throw new Error("Should not happen");
+        }
+        return this._uuid;
+    }
+    get created() {
+        if (this._created === undefined) {
+            throw new Error("Should not happen");
+        }
+        return this._created;
+    }
+    get modified() {
+        if (this._modified === undefined) {
+            throw new Error("Should not happen");
+        }
+        return this._modified;
+    }
+    get url() {
+        return this._url;
+    }
+    get previewUrl() {
+        return this._previewUrl;
+    }
+    stop() {
+        clearInterval(this._timerId);
+    }
+}
+class TaskRender extends Task {
+    constructor(taskHandler, format, product, taskParams, getPreviewUrl) {
+        super(taskHandler, format, product, getPreviewUrl);
+        this.taskParams = taskParams;
+    }
+    static make(taskHandler, format, product, taskParams, getPreviewUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const t = new TaskRender(taskHandler, format, product, taskParams, getPreviewUrl);
+            yield t.startAndRegister();
+            return t;
+        });
+    }
+    postInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.taskHandler.api.postRender(this._productParams, Object.assign(Object.assign(Object.assign({}, this._apiSelection), this.taskParams), { format: this.format, width: Math.floor(this.taskParams.width), height: Math.floor(this.taskParams.height) }))).renderStatus;
+        });
+    }
+    pollStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.taskHandler.api.getRenderById({ uuid: this.uuid })).renderStatus;
+        });
+    }
+}
+class TaskExport extends Task {
+    static make(taskHandler, format, product, getPreviewUrl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const t = new TaskExport(taskHandler, format, product, getPreviewUrl);
+            yield t.startAndRegister();
+            return t;
+        });
+    }
+    postInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.taskHandler.api.postExport(this._productParams, Object.assign(Object.assign({}, this._apiSelection), { format: this.format }))).exportStatus;
+        });
+    }
+    pollStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.taskHandler.api.getExportById({ uuid: this.uuid })).exportStatus;
+        });
+    }
+}

package/dist/tasks/formats.d.ts

@@ -0,0 +1,5 @@
+import { ExportFormat, RenderFormat } from "../CatalogueAPI.js";
+export declare type RenderOrExportFormat = RenderFormat | ExportFormat;
+export declare function isRenderFormat(type: unknown): type is RenderFormat;
+export declare function isExportFormat(type: unknown): type is ExportFormat;
+//# sourceMappingURL=formats.d.ts.map

package/dist/tasks/formats.js

@@ -0,0 +1,7 @@
+import { exportFormatNames, renderFormatNames, } from "../CatalogueAPI.js";
+export function isRenderFormat(type) {
+    return renderFormatNames.some((f) => type === f);
+}
+export function isExportFormat(type) {
+    return exportFormatNames.some((f) => type === f);
+}

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

@@ -1,74 +1,74 @@
-import { CfgProduct } from "../../CfgProduct";
-import { CfgFeature } from "../../productConfiguration/CfgFeature";
-import { CfgOption } from "../../productConfiguration/CfgOption";
-import { CfgProductConfiguration } from "../../productConfiguration/CfgProductConfiguration";
-declare type SnapShotForWrapper = {
-    path: string;
-    selected: boolean;
-};
-declare type SnapShotForWrapperWithoutRef = SnapShotForWrapper & {
-    productConfiguration: SnapShotForConfiguration;
-    additionalProducts: SnapShotForWrapper[];
-};
-declare type SnapShotForWrapperWithRef = SnapShotForWrapper & {
-    ref: CfgProduct;
-    productConfiguration: SnapShotForConfigurationWithRef;
-    additionalProducts: SnapShotForWrapperWithRef[];
-};
-declare type SnapShotForConfiguration = {
-    path: string;
-};
-declare type SnapShotForConfigurationWithoutRef = SnapShotForConfiguration & {
-    features: SnapShotForFeature[];
-};
-declare type SnapShotForConfigurationWithRef = SnapShotForConfiguration & {
-    ref: CfgProductConfiguration;
-    features: SnapShotForFeatureWithRef[];
-};
-declare type SnapShotForFeature = {
-    path: string;
-};
-declare type SnapShotForFeatureWithoutRef = SnapShotForFeature & {
-    options: SnapShotForOption[];
-};
-declare type SnapShotForFeatureWithRef = SnapShotForFeature & {
-    ref: CfgFeature;
-    options: SnapShotForOptionWithRef[];
-};
-declare type SnapShotForOption = {
-    path: string;
-    selected: boolean;
-};
-declare type SnapShotForOptionWithoutRef = SnapShotForOption & {
-    features: SnapShotForFeature[];
-};
-declare type SnapShotForOptionWithRef = SnapShotForOption & {
-    ref: CfgOption;
-    features: SnapShotForFeatureWithRef[];
-};
-export declare class Collector {
-    product: CfgProduct;
-    static stripRefsForWrapper: (w: SnapShotForWrapperWithRef) => SnapShotForWrapperWithoutRef;
-    static stripRefsForConf: (c: SnapShotForConfigurationWithRef) => SnapShotForConfigurationWithoutRef;
-    static stripRefsForFeature: (f: SnapShotForFeatureWithRef) => SnapShotForFeatureWithoutRef;
-    static stripRefsForOption: (o: SnapShotForOptionWithRef) => SnapShotForOptionWithoutRef;
-    constructor(product: CfgProduct);
-    notifications: string[];
-    pushNotification: (message: string) => void;
-    takeSnapshot: () => SnapShotForWrapperWithRef;
-    compareSnapshot: (o: SnapShotForWrapperWithRef, n: SnapShotForWrapperWithRef) => string[];
-    takeRefSnapshotForWrapper: (path: string, product: CfgProduct) => SnapShotForWrapperWithRef;
-    compareSnapshotForWrapper: (result: string[], o: SnapShotForWrapperWithRef, n: SnapShotForWrapperWithRef) => void;
-    takeRefSnapshopForConf: (path: string, productConfiguration: CfgProductConfiguration) => SnapShotForConfigurationWithRef;
-    compareSnapshopForConf: (result: string[], o: SnapShotForConfigurationWithRef, n: SnapShotForConfigurationWithRef) => void;
-    takeRefSnapshotForFeature: (path: string, feature: CfgFeature) => SnapShotForFeatureWithRef;
-    compareSnapshopForFeature: (result: string[], o: SnapShotForFeatureWithRef, n: SnapShotForFeatureWithRef) => void;
-    takeRefSnapshotForOption: (path: string, option: CfgOption) => SnapShotForOptionWithRef;
-    compareSnapshopForOption: (result: string[], o: SnapShotForOptionWithRef, n: SnapShotForOptionWithRef) => void;
-    addListenersForProduct: (path: string, product: CfgProduct) => void;
-    addListenersForProductConfiguration: (path: string, productConfiguration: CfgProductConfiguration) => void;
-    addListenersForFeature: (path: string, feature: CfgFeature) => void;
-    addListenersForOption: (path: string, option: CfgOption) => void;
-}
-export {};
+import { CfgProduct } from "../../CfgProduct";
+import { CfgFeature } from "../../productConfiguration/CfgFeature";
+import { CfgOption } from "../../productConfiguration/CfgOption";
+import { CfgProductConfiguration } from "../../productConfiguration/CfgProductConfiguration";
+declare type SnapShotForWrapper = {
+    path: string;
+    selected: boolean;
+};
+declare type SnapShotForWrapperWithoutRef = SnapShotForWrapper & {
+    productConfiguration: SnapShotForConfiguration;
+    additionalProducts: SnapShotForWrapper[];
+};
+declare type SnapShotForWrapperWithRef = SnapShotForWrapper & {
+    ref: CfgProduct;
+    productConfiguration: SnapShotForConfigurationWithRef;
+    additionalProducts: SnapShotForWrapperWithRef[];
+};
+declare type SnapShotForConfiguration = {
+    path: string;
+};
+declare type SnapShotForConfigurationWithoutRef = SnapShotForConfiguration & {
+    features: SnapShotForFeature[];
+};
+declare type SnapShotForConfigurationWithRef = SnapShotForConfiguration & {
+    ref: CfgProductConfiguration;
+    features: SnapShotForFeatureWithRef[];
+};
+declare type SnapShotForFeature = {
+    path: string;
+};
+declare type SnapShotForFeatureWithoutRef = SnapShotForFeature & {
+    options: SnapShotForOption[];
+};
+declare type SnapShotForFeatureWithRef = SnapShotForFeature & {
+    ref: CfgFeature;
+    options: SnapShotForOptionWithRef[];
+};
+declare type SnapShotForOption = {
+    path: string;
+    selected: boolean;
+};
+declare type SnapShotForOptionWithoutRef = SnapShotForOption & {
+    features: SnapShotForFeature[];
+};
+declare type SnapShotForOptionWithRef = SnapShotForOption & {
+    ref: CfgOption;
+    features: SnapShotForFeatureWithRef[];
+};
+export declare class Collector {
+    product: CfgProduct;
+    static stripRefsForWrapper: (w: SnapShotForWrapperWithRef) => SnapShotForWrapperWithoutRef;
+    static stripRefsForConf: (c: SnapShotForConfigurationWithRef) => SnapShotForConfigurationWithoutRef;
+    static stripRefsForFeature: (f: SnapShotForFeatureWithRef) => SnapShotForFeatureWithoutRef;
+    static stripRefsForOption: (o: SnapShotForOptionWithRef) => SnapShotForOptionWithoutRef;
+    constructor(product: CfgProduct);
+    notifications: string[];
+    pushNotification: (message: string) => void;
+    takeSnapshot: () => SnapShotForWrapperWithRef;
+    compareSnapshot: (o: SnapShotForWrapperWithRef, n: SnapShotForWrapperWithRef) => string[];
+    takeRefSnapshotForWrapper: (path: string, product: CfgProduct) => SnapShotForWrapperWithRef;
+    compareSnapshotForWrapper: (result: string[], o: SnapShotForWrapperWithRef, n: SnapShotForWrapperWithRef) => void;
+    takeRefSnapshopForConf: (path: string, productConfiguration: CfgProductConfiguration) => SnapShotForConfigurationWithRef;
+    compareSnapshopForConf: (result: string[], o: SnapShotForConfigurationWithRef, n: SnapShotForConfigurationWithRef) => void;
+    takeRefSnapshotForFeature: (path: string, feature: CfgFeature) => SnapShotForFeatureWithRef;
+    compareSnapshopForFeature: (result: string[], o: SnapShotForFeatureWithRef, n: SnapShotForFeatureWithRef) => void;
+    takeRefSnapshotForOption: (path: string, option: CfgOption) => SnapShotForOptionWithRef;
+    compareSnapshopForOption: (result: string[], o: SnapShotForOptionWithRef, n: SnapShotForOptionWithRef) => void;
+    addListenersForProduct: (path: string, product: CfgProduct) => void;
+    addListenersForProductConfiguration: (path: string, productConfiguration: CfgProductConfiguration) => void;
+    addListenersForFeature: (path: string, feature: CfgFeature) => void;
+    addListenersForOption: (path: string, option: CfgOption) => void;
+}
+export {};
 //# sourceMappingURL=collectorForTest.d.ts.map