@salesforce/b2c-cli 1.11.0 → 1.12.0

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/customer/shoppercontext/ShopperContextMgr.d.ts

@@ -0,0 +1,130 @@
+import ShopperContext = require('./ShopperContext');
+import Geolocation = require('../../util/Geolocation');
+
+/**
+ * 
+ * 
+ * Provides static helper methods for managing Shopper Context.
+ * 
+ * Shopper Context is used to personalize shopper experiences with context values such as custom session attributes,
+ * assignment qualifiers, geolocation, effective datetime, source code and more. When Shopper Context is set for a
+ * shopper, it can activate promotions or price books assigned to customer groups, source codes, or stores (via
+ * assignments) in the subsequent requests, not the current request.
+ * 
+ * Shopper Context is used to personalize the shopper experience in case of Composable/Headless or Hybrid storefront
+ * implementations that use Shopper Login and API Access Service (SLAS).
+ * 
+ * NOTE: This script API is not intended to be used for standard server-side storefront implementations. Only for
+ * Composable/Headless or Hybrid storefront implementations.
+ * 
+ * Unlike dw.customer.CustomerContextMgr which is used to set just Effective Time for which the customer is
+ * shopping at, Shopper Context API provides a way to set many types of contexts such as custom session attributes,
+ * assignment qualifiers, geolocation, effective datetime, source code etc.
+ * 
+ * The following feature toggles and site preferences must be enabled in order to use this script API:
+ * 
+ * - Enable Shopper Context Feature
+ * - Hybrid Auth Settings' site preference - only in case of Hybrid storefront implementations
+ * 
+ * For more details on Shopper Context please refer to: Shopper Context
+ * API Overview
+ * 
+ * For more details on Hybrid Authentication for Hybrid storefronts please refer to:
+ * Hybrid
+ * Authentication
+ * 
+ * dw.customer.shoppercontext.ShopperContextMgr is used to create, access and delete Shopper Context.
+ * 
+ * - To add Shopper Context, use methods setShopperContext.
+ * - To access Shopper Context, use method getShopperContext.
+ * - To delete Shopper Context, use methods removeShopperContext.
+ * - To fetch Geolocation based on clientIP already set in Shopper Context, use method getGeolocation
+ * 
+ * Typical usage:
+ * 
+ * ```
+ * `
+ * // get the ShopperContext if it exists
+ * ShopperContext context = ShopperContextMgr.getShopperContext();
+ * if (context == null) {
+ * context = new ShopperContext();
+ * }
+ * // set the values in the ShopperContext object
+ * context.setSourceCode( "sourcecode" );
+ * var customQualifiers = new dw.util.HashMap();
+ * customQualifiers.put( "deviceType", "iPad" );
+ * context.setCustomQualifiers( customQualifiers );
+ * // Save the ShopperContext
+ * ShopperContextMgr.setShopperContext( context, true );
+ * `
+ * ```
+ * 
+ * NOTE: Ensure the ShopperContext object is saved using setShopperContext after
+ * setting or updating the context values.
+ */
+declare class ShopperContextMgr {
+    /**
+     * Gets the dw.util.Geolocation object for the clientIP set in
+     * dw.customer.shoppercontext.ShopperContext or null if no shopperContext is found, or no clientIP was set
+     * or Geolocation for the clientIP was not found.
+     * 
+     * The method throws an exception if the call fails.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if error occurs while trying to retrieve Geolocation string from the Shopper Context.
+     */
+    static readonly geolocation: Geolocation | null;
+    /**
+     * Returns the dw.customer.shoppercontext.ShopperContext if it exists for the customer. Returns null if it
+     * does not exist.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if an error occurs while fetching the Shopper Context.
+     */
+    static readonly shopperContext: ShopperContext | null;
+    private constructor();
+    /**
+     * Gets the dw.util.Geolocation object for the clientIP set in
+     * dw.customer.shoppercontext.ShopperContext or null if no shopperContext is found, or no clientIP was set
+     * or Geolocation for the clientIP was not found.
+     * 
+     * The method throws an exception if the call fails.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if error occurs while trying to retrieve Geolocation string from the Shopper Context.
+     */
+    static getGeolocation(): Geolocation | null;
+    /**
+     * Returns the dw.customer.shoppercontext.ShopperContext if it exists for the customer. Returns null if it
+     * does not exist.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if an error occurs while fetching the Shopper Context.
+     */
+    static getShopperContext(): ShopperContext | null;
+    /**
+     * Removes the dw.customer.shoppercontext.ShopperContext for the customer.
+     * 
+     * The method throws an exception if the deletion of Shopper Context fails.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if error occurs while deleting the Shopper Context.
+     */
+    static removeShopperContext(): void;
+    /**
+     * 
+     * 
+     * Sets new dw.customer.shoppercontext.ShopperContext for the customer or overwrites the existing context.
+     * 
+     * Note: This method does not save the attributes from the given Shopper Context such as - custom session
+     * attributes, source code, effective date time etc., - in the current session object. These attributes are read
+     * from Shopper Context and stored in the corresponding session attributes during subsequent requests and not in the
+     * current request. Hence, promotions, price books etc., are triggered in subsequent requests.
+     * 
+     * If `clientIP` is set in dw.customer.shoppercontext.ShopperContext, the geolocation information
+     * is retrieved and set in `x-geolocation` header.
+     * 
+     * And if the parameter `evaluateContextWithClientIP` is set to true, the `clientIP` will be
+     * saved to the Shopper Context.
+     * 
+     * If parameter `evaluateContextWithClientIP` is set to false, the `clientIP` will not be
+     * saved to the Shopper Context.
+     * 
+     * If the `geoLocation` attribute is set, it overrides any geolocation context set by
+     * `clientIP`.
+     * @throws dw.customer.shoppercontext.ShopperContextException This exception is thrown if the Shopper Context is not saved or if validation fails.
+     */
+    static setShopperContext(shopperContext: ShopperContext, evaluateContextWithClientIP: boolean): void;
+}
+
+export = ShopperContextMgr;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/customer/shoppercontext/index.d.ts

@@ -0,0 +1,11 @@
+import ShopperContext = require('./ShopperContext');
+import ShopperContextErrorCodes = require('./ShopperContextErrorCodes');
+import ShopperContextException = require('./ShopperContextException');
+import ShopperContextMgr = require('./ShopperContextMgr');
+
+export {
+    ShopperContext,
+    ShopperContextErrorCodes,
+    ShopperContextException,
+    ShopperContextMgr
+};

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/AspectAttributeValidationException.d.ts

@@ -0,0 +1,11 @@
+/**
+ * This APIException is thrown by method PageMgr.renderPage
+ * and PageMgr.serializePage
+ * to indicate that the passed aspect attributes failed during validation against the
+ * definition provided through the aspect type of the page.
+ */
+declare class AspectAttributeValidationException {
+    private constructor();
+}
+
+export = AspectAttributeValidationException;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/Component.d.ts

@@ -0,0 +1,83 @@
+import Region = require('./Region');
+
+/**
+ * This class represents a page designer managed component as part of a
+ * page. A component comprises of multiple regions that again hold components,
+ * thus spanning a hierarchical tree of components. Using the PageMgr.renderRegion or
+ * PageMgr.renderRegion a region can be rendered which
+ * implicitly includes rendering of all contained visible components. All
+ * content attributes (defined by the corresponding component type) can be
+ * accessed, reading the accordant persisted values as provided by the content editor
+ * who created this component.
+ * @see Page
+ * @see Region
+ * @see PageMgr
+ */
+declare class Component {
+    /**
+     * Returns the id of this component.
+     */
+    readonly ID: string;
+    /**
+     * Returns the name of this component
+     */
+    readonly name: string;
+    /**
+     * Returns the type id of this component.
+     */
+    readonly typeID: string;
+    private constructor();
+    /**
+     * 
+     * Returns the raw attribute value identified by the specified attribute id.
+     * By raw attribute value we denote the unprocessed value as provided for the attribute
+     * driven by the type of the respective attribute definition:
+     * 
+     * - `boolean` -> boolean
+     * - `category` -> string representing a catalog category ID
+     * - `custom` -> dw.util.Map that originates from a stringified curly brackets {} JSON object
+     * - `cms_record` -> dw.util.Map that originates from a stringified curly brackets {} JSON object whose entries must adhere to the `cmsrecord.json` schema
+     * - `enum` -> either string or integer
+     * - `file` -> string representing a file path within a library
+     * - `image` -> dw.util.Map that originates from a stringified curly brackets {} JSON object whose entries must adhere to the `content/schema/image.json` schema
+     * - `integer` -> integer
+     * - `markup` -> string representing HTML markup
+     * - `page` -> string representing a page ID
+     * - `product` -> string representing a product SKU
+     * - `string` -> string
+     * - `text` -> string
+     * - `url` -> string representing a URL
+     * 
+     * There is two places an attribute value can come from - either it was persisted at design time (e.g.
+     * by the merchant by editing a component in Page Designer) or it was injected in shape of an aspect attribute at rendering time
+     * through the execution of code. The persistent value, if existing, takes precedence over the injected aspect
+     * attribute one. Injection of a value through an aspect attribute will only occur if the component attribute's
+     * attribute definition was declared using the `"dynamic_lookup"` property and its aspect attribute alias matches
+     * the ID of the respective aspect attribute.
+     * 
+     * Accessing the raw value can be helpful if render and serialization logic of the
+     * component needs to operate on these unprocessed values. An unprocessed value
+     * might be fundamentally different from its processed counterpart, the latter being
+     * provided through the content dictionary (see ComponentScriptContext.getContent)
+     * when the render/serialize function of the component is invoked.
+     */
+    getAttribute(attributeID: string): any | null;
+    /**
+     * Returns the id of this component.
+     */
+    getID(): string;
+    /**
+     * Returns the name of this component
+     */
+    getName(): string;
+    /**
+     * Returns the component region that matches the given id.
+     */
+    getRegion(id: string): Region | null;
+    /**
+     * Returns the type id of this component.
+     */
+    getTypeID(): string;
+}
+
+export = Component;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/ComponentRenderSettings.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A config that drives how the component is rendered. One can basically decide which kind of tag is used as wrapper
+ * element (e.g. `<div>...</div>`) and which attributes are to be placed into this wrapper
+ * element (e.g. `class="foo bar"`). In case no attributes are provided then the system default settings will
+ * apply. In case no tag name is provided then the system default one will apply.
+ * 
+ * - tag_name : div
+ * - attributes : {"class":"experience-component experience-[COMPONENT_TYPE_ID]"}
+ * 
+ * As the [COMPONENT_TYPE_ID] can contain dots due to its package like naming scheme (e.g. assets.image)
+ * any occurrences of these dots will be replaced by dashes (e.g. assets-image) so that CSS selectors
+ * do not have to be escaped.
+ * @see RegionRenderSettings
+ */
+declare class ComponentRenderSettings {
+    /**
+     * Returns the configured attributes of the wrapper element as set by setAttributes.
+     */
+    attributes: any;
+    /**
+     * Returns the tag name of the component wrapper element. Defaults to 'div'.
+     */
+    tagName: string;
+    /**
+     * Creates region render settings which can then be configured further. They are to be used for detailed
+     * configuration of a RegionRenderSettings which is subsequently used for
+     * PageMgr.renderRegion calls.
+     * @see RegionRenderSettings
+     */
+    constructor();
+    /**
+     * Returns the configured attributes of the wrapper element as set by setAttributes.
+     */
+    getAttributes(): any;
+    /**
+     * Returns the tag name of the component wrapper element. Defaults to 'div'.
+     */
+    getTagName(): string;
+    /**
+     * Sets the to be configured <String,String> attributes of the wrapper element. Set it to `null` in case
+     * you want to system defaults to be applied.
+     */
+    setAttributes(attributes: Object): ComponentRenderSettings;
+    /**
+     * Sets the tag name of the component wrapper element. Must not be empty.
+     */
+    setTagName(tagName: string): ComponentRenderSettings;
+}
+
+export = ComponentRenderSettings;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/ComponentScriptContext.d.ts

@@ -0,0 +1,96 @@
+import Component = require('./Component');
+import ComponentRenderSettings = require('./ComponentRenderSettings');
+import utilMap = require('../util/Map');
+
+/**
+ * This is the context that is handed over to the `render` and `serialize` function of the respective component type
+ * script.
+ * @example
+ * `String : render( ComponentScriptContext context)`
+ * `Object : serialize( ComponentScriptContext context)`
+ */
+declare class ComponentScriptContext {
+    /**
+     * Returns the component for which the corresponding component type script is currently executed.
+     */
+    readonly component: Component;
+    /**
+     * As components are implicitly rendered as part of their hosting region via
+     * PageMgr.renderRegion there is the possibility
+     * to define render settings for the region itself but also for its contained components.
+     * The latter will be provided here so you further set or refine them for your component
+     * as part of the `render` function, i.e. to drive the shape of the
+     * component wrapper element.
+     */
+    readonly componentRenderSettings: ComponentRenderSettings;
+    /**
+     * Returns the processed version of the underlying unprocessed raw values (also see Component.getAttribute)
+     * of this component's attributes which you can use in your respective component type `render` and `serialize` function
+     * implementing your business and rendering/serialization functionality. Processing the raw value is comprised of expansion
+     * and conversion, in this order.
+     * 
+     * - expansion - dynamic placeholders are transformed into actual values, for example url/link placeholders in
+     * markup text are resolved to real URLs
+     * - conversion - the raw value (see Component.getAttribute) is resolved into an actual
+     * DWScript object depending on the type of the attribute as specified in its respective attribute definition
+     * 
+     * - `boolean` -> boolean
+     * - `category` -> dw.catalog.Category
+     * - `custom` -> dw.util.Map
+     * - `cms_record` -> dw.experience.cms.CMSRecord
+     * - `enum` -> either string or integer
+     * - `file` -> dw.content.MediaFile
+     * - `image` -> dw.experience.image.Image
+     * - `integer` -> integer
+     * - `markup` -> string
+     * - `page` -> string
+     * - `product` -> dw.catalog.Product
+     * - `string` -> string
+     * - `text` -> string
+     * - `url` -> string
+     */
+    readonly content: utilMap<any, any>;
+    private constructor();
+    /**
+     * Returns the component for which the corresponding component type script is currently executed.
+     */
+    getComponent(): Component;
+    /**
+     * As components are implicitly rendered as part of their hosting region via
+     * PageMgr.renderRegion there is the possibility
+     * to define render settings for the region itself but also for its contained components.
+     * The latter will be provided here so you further set or refine them for your component
+     * as part of the `render` function, i.e. to drive the shape of the
+     * component wrapper element.
+     */
+    getComponentRenderSettings(): ComponentRenderSettings;
+    /**
+     * Returns the processed version of the underlying unprocessed raw values (also see Component.getAttribute)
+     * of this component's attributes which you can use in your respective component type `render` and `serialize` function
+     * implementing your business and rendering/serialization functionality. Processing the raw value is comprised of expansion
+     * and conversion, in this order.
+     * 
+     * - expansion - dynamic placeholders are transformed into actual values, for example url/link placeholders in
+     * markup text are resolved to real URLs
+     * - conversion - the raw value (see Component.getAttribute) is resolved into an actual
+     * DWScript object depending on the type of the attribute as specified in its respective attribute definition
+     * 
+     * - `boolean` -> boolean
+     * - `category` -> dw.catalog.Category
+     * - `custom` -> dw.util.Map
+     * - `cms_record` -> dw.experience.cms.CMSRecord
+     * - `enum` -> either string or integer
+     * - `file` -> dw.content.MediaFile
+     * - `image` -> dw.experience.image.Image
+     * - `integer` -> integer
+     * - `markup` -> string
+     * - `page` -> string
+     * - `product` -> dw.catalog.Product
+     * - `string` -> string
+     * - `text` -> string
+     * - `url` -> string
+     */
+    getContent(): utilMap<any, any>;
+}
+
+export = ComponentScriptContext;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/CustomEditor.d.ts

@@ -0,0 +1,80 @@
+import utilMap = require('../util/Map');
+import CustomEditorResources = require('./CustomEditorResources');
+
+/**
+ * This class represents a custom editor for component attributes of type `custom`. It is instantiated
+ * by Page Designer and is subsequently used there for editing of such attributes by the merchant in a visual manner.
+ * It therefore serves the Page Designer with all information required by such UI. What exactly
+ * this information will be is up to the developer of the respective custom editor UI, i.e. depends on the respective
+ * json and js files written for both the attribute definition as well as the custom editor type. Currently a configuration can be
+ * served (basically values passed to Page Designer so that it can bootstrap the custom editor UI on the client side).
+ * Furthermore resources can be served, which are URLs to scripts and styles required by the same UI (you will
+ * likely require your own Javascript and CSS there).
+ * 
+ * You can access the aforementioned configuration as provided through the editor definition of the respective attribute
+ * definition, which you can also adjust in the `init` function (see corresponding js file of your custom editor
+ * type) that is called during initialization of the custom editor, i.e. right before it is passed to the Page Designer UI.
+ * The same applies for the script and style resources which you specified as part of your custom editor type and which you
+ * can refine with the `init` function as needed.
+ */
+declare class CustomEditor {
+    /**
+     * Returns the configuration of the custom editor. This is initialized with the values as provided
+     * through the editor definition of the respective attribute definition of type `custom`.
+     * Be aware that this configuration will have to be serializable to JSON itself as it will be passed
+     * to Page Designer for processing in the UI. So you must not add any values in this map that are not
+     * properly serializable. Do not use complex DWScript classes that do not support JSON serialization
+     * like for instance dw.catalog.Product.
+     */
+    readonly configuration: utilMap<any, any>;
+    /**
+     * 
+     * 
+     * Returns the dependencies to other custom editors, e.g. used as breakout elements. You can use
+     * this mapping to add more custom editor dependencies as needed. For this purpose you want to create
+     * a CustomEditor instance via PageMgr.getCustomEditor) and then add it
+     * to the dependencies mapping with an ID of your choice. In the client side logic of Page Designer
+     * you will then be able to access these dependencies again by using the corresponding ID.
+     * 
+     * This is especially helpful if your custom editor for an attribute requires to open a breakout panel,
+     * e.g. for a separate picker required by your custom editor. This picker could be another custom editor,
+     * i.e. the one you declare as dependency here.
+     */
+    readonly dependencies: utilMap<any, any>;
+    /**
+     * Returns the resources of the custom editor. This is initialized with the values as specified
+     * by the custom editor type json (see the respective styles and scripts section).
+     */
+    readonly resources: CustomEditorResources;
+    private constructor();
+    /**
+     * Returns the configuration of the custom editor. This is initialized with the values as provided
+     * through the editor definition of the respective attribute definition of type `custom`.
+     * Be aware that this configuration will have to be serializable to JSON itself as it will be passed
+     * to Page Designer for processing in the UI. So you must not add any values in this map that are not
+     * properly serializable. Do not use complex DWScript classes that do not support JSON serialization
+     * like for instance dw.catalog.Product.
+     */
+    getConfiguration(): utilMap<any, any>;
+    /**
+     * 
+     * 
+     * Returns the dependencies to other custom editors, e.g. used as breakout elements. You can use
+     * this mapping to add more custom editor dependencies as needed. For this purpose you want to create
+     * a CustomEditor instance via PageMgr.getCustomEditor) and then add it
+     * to the dependencies mapping with an ID of your choice. In the client side logic of Page Designer
+     * you will then be able to access these dependencies again by using the corresponding ID.
+     * 
+     * This is especially helpful if your custom editor for an attribute requires to open a breakout panel,
+     * e.g. for a separate picker required by your custom editor. This picker could be another custom editor,
+     * i.e. the one you declare as dependency here.
+     */
+    getDependencies(): utilMap<any, any>;
+    /**
+     * Returns the resources of the custom editor. This is initialized with the values as specified
+     * by the custom editor type json (see the respective styles and scripts section).
+     */
+    getResources(): CustomEditorResources;
+}
+
+export = CustomEditor;

package/dist/script-types/node_modules/@salesforce/b2c-script-types/types/dw/experience/CustomEditorResources.d.ts

@@ -0,0 +1,51 @@
+import List = require('../util/List');
+
+/**
+ * This class represents the resources of a custom editor, i.e. URLs to scripts and styles which are required for
+ * client side functionality in Page Designer in context of the corresponding custom attribute UI. These resources
+ * are initially specified as part of your custom editor type (i.e. the respective json file). If needed you can
+ * revise and refine them as part of the `init` function that is called during initialization of the
+ * CustomEditor, i.e. is subject to your implementation of the respective custom editor type js file.
+ * @see CustomEditor
+ */
+declare class CustomEditorResources {
+    /**
+     * Returns the specified script resource URLs. You can further modify this list
+     * at runtime of your `init` function to add more required scripts.
+     * Absolute URLs will be retained, relative paths will be resolved to absolute
+     * ones based on the cartridge path for static resources (e.g. similar to
+     * what dw.web.URLUtils.httpStatic or
+     * dw.web.URLUtils.httpsStatic) does.
+     */
+    readonly scripts: List<string>;
+    /**
+     * Returns the specified style URLs. You can further modify this list
+     * at runtime of your `init` function to add more required styles.
+     * Absolute URLs will be retained, relative paths will be resolved to absolute
+     * ones based on the cartridge path for static resources (e.g. similar to
+     * what dw.web.URLUtils.httpStatic or
+     * dw.web.URLUtils.httpsStatic) does.
+     */
+    readonly styles: List<string>;
+    private constructor();
+    /**
+     * Returns the specified script resource URLs. You can further modify this list
+     * at runtime of your `init` function to add more required scripts.
+     * Absolute URLs will be retained, relative paths will be resolved to absolute
+     * ones based on the cartridge path for static resources (e.g. similar to
+     * what dw.web.URLUtils.httpStatic or
+     * dw.web.URLUtils.httpsStatic) does.
+     */
+    getScripts(): List<string>;
+    /**
+     * Returns the specified style URLs. You can further modify this list
+     * at runtime of your `init` function to add more required styles.
+     * Absolute URLs will be retained, relative paths will be resolved to absolute
+     * ones based on the cartridge path for static resources (e.g. similar to
+     * what dw.web.URLUtils.httpStatic or
+     * dw.web.URLUtils.httpsStatic) does.
+     */
+    getStyles(): List<string>;
+}
+
+export = CustomEditorResources;