@configura/web-api 1.3.0-alpha.1 → 1.3.0-alpha.5

package/dist/CatalogueAPI.d.ts

@@ -11,6 +11,7 @@ export interface AdditionalProductRef {
     catId: CatalogueParams;
     partNumber: string;
     refDescription?: string;
+    anchor?: MeasureParam;
     transform?: Transform;
     optional?: boolean;
 }
@@ -59,6 +60,20 @@ export interface CataloguePermission {
 export interface CategoryMap {
     [index: string]: string;
 }
+/** CodeRange */
+export interface CodeRange {
+    minValue: number;
+    maxValue: number;
+    increment?: number;
+}
+/** ConnectorRef */
+export interface ConnectorRef {
+    code: string;
+    connectRule: string;
+    visible: boolean;
+    anchor?: MeasureParam;
+    transform: Transform;
+}
 /** ErrorResponse */
 export interface ErrorResponse {
     error: string;
@@ -95,10 +110,14 @@ export interface Feature {
     groupCode?: string;
     mtrlApplications?: Array<MtrlApplication>;
     multiple?: boolean;
+    numericOrder: boolean;
     optional?: boolean;
     options: Array<Option>;
     hideIfMainProduct?: boolean;
     hideIfAdditionalProduct?: boolean;
+    measureParams?: Array<MeasureParam>;
+    syncGroup?: SyncGroup;
+    unit?: string;
 }
 /** FeatureRef */
 export interface FeatureRef {
@@ -172,9 +191,26 @@ export interface Level {
 export interface LevelProductRef {
     prdRef: string;
 }
+/** Measurement */
+export interface Measurement {
+    code: string;
+    numericValue?: ValueWithUnit;
+    measureParam?: MeasureParam;
+}
+/** MeasureParam */
+export interface MeasureParam {
+    code: string;
+    anchorPoint?: string;
+    measurePriority?: Array<MeasurePriority>;
+}
+/** MeasurePriority */
+export interface MeasurePriority {
+    url: string;
+}
 /** Model */
 export interface Model {
     cid: number;
+    anchor?: MeasureParam;
     t?: Transform;
     uri: string;
 }
@@ -187,12 +223,13 @@ export interface MtrlApplication {
 }
 /** Option */
 export interface Option {
+    additionalProductRefs?: Array<AdditionalProductRef>;
     code: string;
     description: string;
     featureRefs?: Array<FeatureRef>;
     material?: string;
     mtrlApplications?: Array<MtrlApplication>;
-    additionalProductRefs?: Array<AdditionalProductRef>;
+    codeRanges?: Array<CodeRange>;
     upcharge?: number;
     priceCodes?: Array<string>;
 }
@@ -216,6 +253,7 @@ export interface PartsData {
 /** PartsSelectedOption */
 export interface PartsSelectedOption {
     code: string;
+    numericValue?: ValueWithUnit;
     description?: string;
     feature: string;
     featDesc: string;
@@ -242,7 +280,7 @@ export interface PostExportParams {
 }
 /** PostPublicAccessTokenAuthorizeParams represents the URL parameters of postPublicAccessTokenAuthorize */
 export interface PostPublicAccessTokenAuthorizeParams {
-    pk: string;
+    accessTokenId: string;
 }
 /** PostRenderParams represents the URL parameters of postRender */
 export interface PostRenderParams {
@@ -305,6 +343,8 @@ export interface ProductData {
     additionalProductRefs?: Array<AdditionalProductRef>;
     navImage?: string;
     sku: string;
+    measurements?: Array<Measurement>;
+    connectorRefs?: Array<ConnectorRef>;
     tags?: Array<{
         [index: string]: string;
     }>;
@@ -330,6 +370,7 @@ export interface ProductResponse {
     rootFeatureRefs: Array<FeatureRef>;
     features: Array<Feature>;
     productData: ProductData;
+    unit: string;
     uuid: string;
 }
 /** RefreshSessionTokenResponse */
@@ -364,6 +405,7 @@ export declare type RenderStatusStatus = "pending" | "running" | "finished" | "f
 /** SelectedOption */
 export interface SelectedOption {
     code: string;
+    numericValue?: ValueWithUnit;
     next?: {
         [index: string]: SelectedOption;
     };
@@ -373,6 +415,13 @@ export interface SuccessResponse {
     uuid: string;
     success: boolean;
 }
+/** SyncGroup */
+export interface SyncGroup {
+    syncGroupCode: string;
+    syncMethod: SyncGroupMethods;
+}
+/** SyncGroupMethods */
+export declare type SyncGroupMethods = "pull" | "push" | "twoWay";
 /** TargetCameraArgs */
 export interface TargetCameraArgs {
     location?: Point;
@@ -410,6 +459,11 @@ export interface ValidateResponse {
     validated: boolean;
     rootFeatureRefs?: Array<FeatureRef>;
 }
+/** ValueWithUnit */
+export interface ValueWithUnit {
+    value: number;
+    unit?: string;
+}
 /** Vector */
 export interface Vector {
     x: number;

package/dist/CatalogueAPI.js

@@ -49,7 +49,7 @@ export class CatalogueAPI {
     }
     postPublicAccessTokenAuthorize(params, endpoint) {
         return __awaiter(this, void 0, void 0, function* () {
-            const url = `/v1/catadmin/access-token/public/${encodeURIComponent(params.pk)}/authorize`;
+            const url = `/v1/access-token/public/${encodeURIComponent(params.accessTokenId)}/authorize`;
             const options = {
                 method: "POST",
                 headers: {},

package/dist/CfgMeasure.d.ts

@@ -0,0 +1,33 @@
+import { Measurement, ValueWithUnit } from "./CatalogueAPI";
+/**
+ * Measures can be used to Anchor items (Models or Additional Products).
+ *
+ * Measures originates in Models, and can then be used in Products. There is nothing stopping
+ * having multiple Models in the same Product that use the same Measure name. If so it is ambiguous
+ * which of the Models in the Product to anchor to.
+ *
+ * Measure Priority tries to solve this by allowing MeasureParams to contain an ordered list
+ * containing which Model should have highest priority (i.e. gets "first dibs") when Anchoring.
+ *
+ * Unfortunately the solution is currently a bit limited - we can not differentiate between Models
+ * pointing to the same URL in a Product. However, we consistently pick the first one.
+ * Lower index = higher priority
+ */
+export declare type CfgMeasurePriority = {
+    index: number;
+    modelLocalFilePath: string;
+};
+/**
+ * This class strips the Measurement of things that are not actually used or relevant
+ * to Stage, specifically anchoring and stretching. Measurments can also contain
+ * volume and area, but these are ignored. Here Measures are used to define defaults
+ * such as its preferences when dealing with ambiguity or its default value.
+ */
+export declare class CfgMeasureDefinition {
+    readonly measureParamCode: string;
+    readonly numericValue: ValueWithUnit | undefined;
+    readonly measurePriorities: CfgMeasurePriority[];
+    static make(measurement: Measurement): CfgMeasureDefinition | undefined;
+    private constructor();
+}
+//# sourceMappingURL=CfgMeasure.d.ts.map

package/dist/CfgMeasure.js

@@ -0,0 +1,30 @@
+/**
+ * This class strips the Measurement of things that are not actually used or relevant
+ * to Stage, specifically anchoring and stretching. Measurments can also contain
+ * volume and area, but these are ignored. Here Measures are used to define defaults
+ * such as its preferences when dealing with ambiguity or its default value.
+ */
+export class CfgMeasureDefinition {
+    constructor(measureParamCode, numericValue, measurePriorities) {
+        this.measureParamCode = measureParamCode;
+        this.numericValue = numericValue;
+        this.measurePriorities = measurePriorities;
+    }
+    static make(measurement) {
+        // The measurement.code seems to be used in CET to connect the value to
+        // pre-existing fields in the product, such as width, height and depth.
+        // We however only use this for anchoring and stretching and so it is the
+        // code of the measureParam that is relevant. Hence Measurements with no
+        // measureParam are ignored.
+        var _a;
+        const measureParam = measurement.measureParam;
+        if (measureParam === undefined) {
+            return undefined;
+        }
+        const code = measureParam.code;
+        return new this(code, measurement.numericValue, ((_a = measureParam.measurePriority) !== null && _a !== void 0 ? _a : []).map((p, index) => ({
+            modelLocalFilePath: p.url,
+            index,
+        })));
+    }
+}

package/dist/CfgProduct.d.ts

@@ -1,5 +1,6 @@
-import { AggregatedLoadingObservable, Observable, SingleArgCallback } from "@configura/web-utilities";
-import { AdditionalProductConfiguration, CatalogueParams, MtrlApplication, Prices, Transform } from "./CatalogueAPI.js";
+import { AggregatedLoadingObservable, LengthUnit, Observable, SingleArgCallback } from "@configura/web-utilities";
+import { AdditionalProductConfiguration, CatalogueParams, MeasureParam, MtrlApplication, Prices, Transform } from "./CatalogueAPI.js";
+import { CfgMeasureDefinition } from "./CfgMeasure.js";
 import { _CfgFeatureInternal } from "./productConfiguration/CfgFeature.js";
 import { ProductConfigurationBubbleMode } from "./productConfiguration/CfgOption.js";
 import { CfgProductConfiguration } from "./productConfiguration/CfgProductConfiguration.js";
@@ -9,13 +10,36 @@ export declare type CfgProductChangeNotification = {
     freshRef: CfgProduct;
 };
 export declare type CfgProductSettings = {
+    /**
+     * In a correctly setup catalogue a select-one Feature (i.e. neither optional nor multiple)
+     * must have exactly one Option set at a time. However, this is not enforced in Catalogue
+     * Creator and it is not uncommon with catalogues which fails to meet this requirement.
+     * Activating this will make setApi throw an Error if more or less than one is selected.
+     */
     strictSelectOneSelectionCount: boolean;
+    /**
+     * Activating this will make setAPI throw an error if the number of actually selected options
+     * on Features (excluding Group) are not exactly equal to the number of options passed in.
+     * Note: This check is not always reliable for Options with multiple Features each, which we
+     * believe is a rare use case.
+     */
     strictSetApiSelectionMatch: boolean;
 };
+/**
+ * This enum is used internally in the SDK and is not expected by be used directly by integrators.
+ */
 export declare enum CfgProductBubbleMode {
+    /** Stop bubbling. */
     Stop = "Stop",
+    /**
+     * Bubble to the parent CfgProduct up the tree.
+     * This makes the CfgProduct we we call from notify that it has changed, and the CfgProduct
+     * above switch out the reference to this.
+     */
     OneLevel = "OneLevel",
+    /** Bubble to the root CfgProduct. */
     ToRoot = "ToRoot",
+    /** Bubble to the root CfgProduct and turn on all optional CfgProducts on the way up. */
     ToRootAndBubbleSelected = "ToRootAndBubbleSelected"
 }
 export declare type CfgPrice = {
@@ -24,6 +48,11 @@ export declare type CfgPrice = {
     currency: string;
     fractionDigits: number;
 };
+/**
+ * This class is meant to only be used through CfgProduct. It should never be instantiated on its
+ * own. Normally the internal state of this class should never be directly modified. CfgProduct is
+ * the class that should be used and interacted with.
+ */
 export declare class _CfgProductInternal {
     readonly _productLoaderRaw: ProductLoader;
     readonly lang: string;
@@ -31,13 +60,15 @@ export declare class _CfgProductInternal {
     readonly partNumber: string;
     readonly settings: CfgProductSettings;
     readonly uuid: string;
+    private readonly _rawUnit;
     private _rawProductData;
     readonly loadingObservable: AggregatedLoadingObservable;
     readonly refKey: string | undefined;
     readonly refDescription: string | undefined;
     readonly parent: _CfgProductInternal | undefined;
     readonly transform: Transform | undefined;
-    static make: (productLoaderRaw: ProductLoader, productLoaderForGroupedLoad: ProductLoader | undefined, lang: string, catId: CatalogueParams, partNumber: string, settings: CfgProductSettings, optional: boolean, loadingObservable: AggregatedLoadingObservable, refKey: string | undefined, refDescription: string | undefined, parent: _CfgProductInternal | undefined, root: _CfgProductInternal | undefined, transform: Transform | undefined) => Promise<_CfgProductInternal>;
+    anchor: MeasureParam | undefined;
+    static make: (productLoaderRaw: ProductLoader, productLoaderForGroupedLoad: ProductLoader | undefined, lang: string, catId: CatalogueParams, partNumber: string, settings: CfgProductSettings, optional: boolean, loadingObservable: AggregatedLoadingObservable, refKey: string | undefined, refDescription: string | undefined, parent: _CfgProductInternal | undefined, root: _CfgProductInternal | undefined, transform: Transform | undefined, anchor: MeasureParam | undefined) => Promise<_CfgProductInternal>;
     private constructor();
     readonly root: _CfgProductInternal;
     private _destroyed;
@@ -56,55 +87,125 @@ export declare class _CfgProductInternal {
     get currency(): string;
     get fractionDigits(): number;
     get prices(): Prices | undefined;
+    private _measureDefinitions;
+    get measureDefinitions(): CfgMeasureDefinition[];
+    private _unit;
+    /** @throws an error if the actual unit sent by the server was not a LengthUnit */
+    get unit(): LengthUnit;
     get aggregatedPrice(): CfgPrice;
     get optional(): boolean;
     setSelected(v: boolean, bubbleMode: CfgProductBubbleMode): Promise<boolean>;
     get configuration(): CfgProductConfiguration;
     get rawProductData(): CfgProductData;
     _notifyAllOfChange: (bubbleMode: CfgProductBubbleMode) => Promise<void>;
+    /** Called when a child (additional product or the configuration) has changed. */
     private _childHasChanged;
+    /** Called by child to tell its parent that it has changed. */
     _additionalProductHasChanged: (freshRef: CfgProduct, bubbleMode: CfgProductBubbleMode) => Promise<void>;
+    /** Called by the configuration to tell its parent that it has changed. */
     _configurationHasChanged: (freshRef: CfgProductConfiguration, bubbleMode: ProductConfigurationBubbleMode) => Promise<void>;
     getApiSelection: () => AdditionalProductConfiguration;
     setApiSelection: (s: AdditionalProductConfiguration, doValidate: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
     structureCompare: (other: _CfgProductInternal, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
     tryMatchSelection: (other: _CfgProductInternal, descriptionMatch?: boolean, productLoaderForGroupedLoad?: ProductLoader | undefined) => Promise<boolean>;
+    /** Only features in selected options and selected additional products. */
     _getDescendantFeaturesWithCode: (code: string) => _CfgFeatureInternal[];
     private _revalidateInProgressToken;
+    /**
+     * Do a validate call for this product. It does not validate additional products, only this
+     * product in isolation. The validation result is applied on the configuration. Then additional
+     * products are synced (unloaded, loaded etc.) Finally the changes bubble up the tree.
+     */
     _revalidate: (bubbleMode: CfgProductBubbleMode, productLoaderForGroupedLoad: ProductLoader) => Promise<boolean>;
+    /**
+     * Based on this configuration find what additional products should be shown and not, unload
+     * (i.e. destroy) those that should no longer be shown, load the new ones.
+     */
     _syncAndLoadAdditionalProducts: (productLoaderForGroupedLoad: ProductLoader) => Promise<boolean>;
 }
 export declare class CfgProduct {
     readonly _internal: _CfgProductInternal;
-    static make: (productLoader: ProductLoader, lang: string, catId: CatalogueParams, partNumber: string, settings?: Partial<CfgProductSettings> | undefined) => Promise<CfgProduct>;
-    static _makeNewRefFrom: (source: _CfgProductInternal) => CfgProduct;
+    static make(productLoader: ProductLoader, lang: string, catId: CatalogueParams, partNumber: string, settings?: Partial<CfgProductSettings>): Promise<CfgProduct>;
+    /**
+     * 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(source: _CfgProductInternal): CfgProduct;
     private constructor();
     isBackedBySame: (other: CfgProduct) => boolean;
+    /**
+     * Recursively marks this and descendants as destroyed so that late events are ignored
+     * correctly. If you destroy one shallow copy of this you destroy all.
+     */
     destroy: () => void;
+    /** Makes a clone of this. It is disconnected from the original. */
     clone: () => Promise<CfgProduct>;
+    /**
+     * A client side only key that should uniquely identify this product amongst other additional
+     * products.
+     */
     get key(): string;
+    /**
+     * Only used when this product is in additional product.
+     * As a product can have multiple instances of the same additional product this key exists.
+     * It will be unique amongst child products, but not globally unique.
+     */
     get refKey(): string | undefined;
     get lang(): string;
     get catId(): CatalogueParams;
     get partNumber(): string;
     get isAdditionalProduct(): boolean;
+    /** Only used when this product is an additional product. Root products are never optional. */
     get optional(): boolean;
+    /**
+     * Only applicable when this product is optional. If this product is not optional this is
+     * always true.
+     */
     get selected(): boolean;
+    /**
+     * Only applicable when this product is optional.
+     * Setting this does not cause a validation call as toggling an optional additional product is
+     *  assumed to always be legal.
+     */
     setSelected: (v: boolean) => Promise<boolean>;
     get rawProductData(): CfgProductData;
     get uuid(): string;
+    get unit(): LengthUnit;
     get sku(): string;
     get styleNr(): string;
+    /** An URL. */
     get preview(): string | undefined;
     get description(): string | undefined;
     get additionalProducts(): CfgProduct[];
     get configuration(): CfgProductConfiguration;
     get transform(): Transform | undefined;
     get currency(): string;
+    /**
+     * If positive the number of fraction digits.
+     * If negative rounding (essentially the number of zeros to the right)
+     */
     get fractionDigits(): number;
     get aggregatedPrice(): CfgPrice;
+    /**
+     * Experimental. Additional products lacks descriptions or keys that are suitably for structure
+     * compare, so we use strict-order when trying to match the additional products. This makes
+     * this method work nicely for different products having pretty much the same child products.
+     */
     structureCompare: (other: CfgProduct, strictOrder?: boolean, descriptionMatch?: boolean) => boolean;
+    /**
+     * Experimental. Additional products lacks descriptions or keys that are suitably for try
+     *  match, so we use strict-order when trying to match the additional products. This makes
+     *  this method work nicely for different products having pretty much the same child products.
+     *  This method does not propagate its selections.
+     *  This method will cause validation calls if something change.
+     */
     tryMatchSelection: (other: CfgProduct, descriptionMatch?: boolean) => Promise<boolean>;
+    /**
+     * Gets what selections has been made on the product, recursively including product
+     * configuration, optional products and additional products. Used when a full view of all
+     * selections on a product is needed, such as when doing Render or Export.
+     */
     getApiSelection: () => AdditionalProductConfiguration;
     setApiSelection: (s: AdditionalProductConfiguration, doValidate?: boolean) => Promise<boolean>;
     listenForChange: (l: SingleArgCallback<CfgProductChangeNotification>) => void;