@spartacus/core
Version:
Spartacus - the core framework
1,171 lines (1,134 loc) • 1.47 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@ngrx/store'), require('rxjs'), require('rxjs/operators'), require('angular-oauth2-oidc'), require('@angular/common'), require('@angular/router'), require('@angular/common/http'), require('@ngrx/effects'), require('@angular/platform-browser'), require('@ngrx/router-store'), require('i18next-http-backend'), require('i18next')) :
typeof define === 'function' && define.amd ? define('@spartacus/core', ['exports', '@angular/core', '@ngrx/store', 'rxjs', 'rxjs/operators', 'angular-oauth2-oidc', '@angular/common', '@angular/router', '@angular/common/http', '@ngrx/effects', '@angular/platform-browser', '@ngrx/router-store', 'i18next-http-backend', 'i18next'], factory) :
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.spartacus = global.spartacus || {}, global.spartacus.core = {}), global.ng.core, global.store, global.rxjs, global.rxjs.operators, global.angularOAuth2Oidc, global.ng.common, global.ng.router, global.ng.common.http, global.effects, global.ng.platformBrowser, global.fromNgrxRouter, global.i18nextHttpBackend, global.i18next));
}(this, (function (exports, i0, i1, rxjs, operators, i1$1, i6, i1$2, i1$3, i1$4, platformBrowser, fromNgrxRouter, i18nextHttpBackend, i18next) { 'use strict';
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () {
return e[k];
}
});
}
});
}
n['default'] = e;
return Object.freeze(n);
}
var i0__namespace = /*#__PURE__*/_interopNamespace(i0);
var i1__namespace$2 = /*#__PURE__*/_interopNamespace(i1);
var i1__namespace = /*#__PURE__*/_interopNamespace(i1$1);
var i6__namespace = /*#__PURE__*/_interopNamespace(i6);
var i1__namespace$1 = /*#__PURE__*/_interopNamespace(i1$2);
var i1__namespace$3 = /*#__PURE__*/_interopNamespace(i1$3);
var i1__namespace$4 = /*#__PURE__*/_interopNamespace(i1$4);
var fromNgrxRouter__namespace = /*#__PURE__*/_interopNamespace(fromNgrxRouter);
var i18nextHttpBackend__default = /*#__PURE__*/_interopDefaultLegacy(i18nextHttpBackend);
var i18next__default = /*#__PURE__*/_interopDefaultLegacy(i18next);
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b)
if (Object.prototype.hasOwnProperty.call(b, p))
d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function () {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s)
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
r = Reflect.decorate(decorators, target, key, desc);
else
for (var i = decorators.length - 1; i >= 0; i--)
if (d = decorators[i])
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); };
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(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());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function () { if (t[0] & 1)
throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f)
throw new TypeError("Generator is already executing.");
while (_)
try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_.label++;
return { value: op[1], done: false };
case 5:
_.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _.ops.pop();
_.trys.pop();
continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_ = 0;
continue;
}
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
_.label = op[1];
break;
}
if (op[0] === 6 && _.label < t[1]) {
_.label = t[1];
t = op;
break;
}
if (t && _.label < t[2]) {
_.label = t[2];
_.ops.push(op);
break;
}
if (t[2])
_.ops.pop();
_.trys.pop();
continue;
}
op = body.call(thisArg, _);
}
catch (e) {
op = [6, e];
y = 0;
}
finally {
f = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
}
var __createBinding = Object.create ? (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
}) : (function (o, m, k, k2) {
if (k2 === undefined)
k2 = k;
o[k2] = m[k];
});
function __exportStar(m, o) {
for (var p in m)
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p))
__createBinding(o, m, p);
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m)
return m.call(o);
if (o && typeof o.length === "number")
return {
next: function () {
if (o && i >= o.length)
o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m)
return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
ar.push(r.value);
}
catch (error) {
e = { error: error };
}
finally {
try {
if (r && !r.done && (m = i["return"]))
m.call(i);
}
finally {
if (e)
throw e.error;
}
}
return ar;
}
/** @deprecated */
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
/** @deprecated */
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++)
s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
}
function __spreadArray(to, from, pack) {
if (pack || arguments.length === 2)
for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar)
ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || from);
}
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n])
i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try {
step(g[n](v));
}
catch (e) {
settle(q[0][3], e);
} }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length)
resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function (v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) {
Object.defineProperty(cooked, "raw", { value: raw });
}
else {
cooked.raw = raw;
}
return cooked;
}
;
var __setModuleDefault = Object.create ? (function (o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function (o, v) {
o["default"] = v;
};
function __importStar(mod) {
if (mod && mod.__esModule)
return mod;
var result = {};
if (mod != null)
for (var k in mod)
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
__createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
function __classPrivateFieldGet(receiver, state, kind, f) {
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a getter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot read private member from an object whose class did not declare it");
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
}
function __classPrivateFieldSet(receiver, state, value, kind, f) {
if (kind === "m")
throw new TypeError("Private method is not writable");
if (kind === "a" && !f)
throw new TypeError("Private accessor was defined without a setter");
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver))
throw new TypeError("Cannot write private member to an object whose class did not declare it");
return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
}
function isObject(item) {
return item && typeof item === 'object' && !Array.isArray(item);
}
function deepMerge(target) {
if (target === void 0) { target = {}; }
var sources = [];
for (var _i = 1; _i < arguments.length; _i++) {
sources[_i - 1] = arguments[_i];
}
if (!sources.length) {
return target;
}
var source = sources.shift() || {};
if (isObject(source)) {
for (var key in source) {
if (source[key] instanceof Date) {
target[key] = source[key];
}
else if (isObject(source[key])) {
if (!target[key] || !isObject(target[key])) {
target[key] = {};
}
deepMerge(target[key], source[key]);
}
else {
target[key] = source[key];
}
}
}
return deepMerge.apply(void 0, __spreadArray([target], __read(sources)));
}
function configFactory() {
return deepMerge({}, i0.inject(DefaultConfig), i0.inject(RootConfig));
}
/**
* Global Configuration, can be used to inject configuration to any part of the app
*/
var Config = /** @class */ (function () {
function Config() {
}
return Config;
}());
Config.ɵfac = i0__namespace.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0__namespace, type: Config, deps: [], target: i0__namespace.ɵɵFactoryTarget.Injectable });
Config.ɵprov = i0__namespace.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0__namespace, type: Config, providedIn: 'root', useFactory: configFactory });
i0__namespace.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.0.5", ngImport: i0__namespace, type: Config, decorators: [{
type: i0.Injectable,
args: [{
providedIn: 'root',
useFactory: configFactory,
}]
}] });
function defaultConfigFactory() {
var _a;
return deepMerge.apply(void 0, __spreadArray([{}], __read(((_a = i0.inject(DefaultConfigChunk, i0.InjectFlags.Optional)) !== null && _a !== void 0 ? _a : []))));
}
/**
* Default Configuration token, used to build Global Configuration, built from DefaultConfigChunks
*/
var DefaultConfig = new i0.InjectionToken('DefaultConfiguration', {
providedIn: 'root',
factory: defaultConfigFactory,
});
function rootConfigFactory() {
var _a;
return deepMerge.apply(void 0, __spreadArray([{}], __read(((_a = i0.inject(ConfigChunk, i0.InjectFlags.Optional)) !== null && _a !== void 0 ? _a : []))));
}
/**
* Root Configuration token, used to build Global Configuration, built from ConfigChunks
*/
var RootConfig = new i0.InjectionToken('RootConfiguration', {
providedIn: 'root',
factory: rootConfigFactory,
});
/**
* Config chunk token, can be used to provide configuration chunk and contribute to the global configuration object.
* Should not be used directly, use `provideConfig` or import `ConfigModule.withConfig` instead.
*/
var ConfigChunk = new i0.InjectionToken('ConfigurationChunk');
/**
* Config chunk token, can be used to provide configuration chunk and contribute to the default configuration.
* Should not be used directly, use `provideDefaultConfig` or `provideDefaultConfigFactory` instead.
*
* General rule is, that all config provided in libraries should be provided as default config.
*/
var DefaultConfigChunk = new i0.InjectionToken('DefaultConfigurationChunk');
/**
* Helper function to provide configuration chunk using ConfigChunk token
*
* To provide default configuration in libraries provideDefaultConfig should be used instead.
*
* @param config Config object to merge with the global configuration
*/
function provideConfig(config, defaultConfig) {
if (config === void 0) { config = {}; }
if (defaultConfig === void 0) { defaultConfig = false; }
return {
provide: defaultConfig ? DefaultConfigChunk : ConfigChunk,
useValue: config,
multi: true,
};
}
/**
* Helper function to provide configuration with factory function, using ConfigChunk token
*
* To provide default configuration in libraries provideDefaultConfigFactory should be used instead.
*
* @param configFactory Factory Function that will generate config object
* @param deps Optional dependencies to a factory function
*/
function provideConfigFactory(configFactory, deps, defaultConfig) {
if (defaultConfig === void 0) { defaultConfig = false; }
return {
provide: defaultConfig ? DefaultConfigChunk : ConfigChunk,
useFactory: configFactory,
multi: true,
deps: deps,
};
}
/**
* Helper function to provide default configuration chunk using DefaultConfigChunk token
*
* @param config Config object to merge with the default configuration
*/
function provideDefaultConfig(config) {
if (config === void 0) { config = {}; }
return {
provide: DefaultConfigChunk,
useValue: config,
multi: true,
};
}
/**
* Helper function to provide default configuration with factory function, using DefaultConfigChunk token
*
* @param configFactory Factory Function that will generate config object
* @param deps Optional dependencies to a factory function
*/
function provideDefaultConfigFactory(configFactory, deps) {
return {
provide: DefaultConfigChunk,
useFactory: configFactory,
multi: true,
deps: deps,
};
}
var defaultAnonymousConsentsConfig = {
anonymousConsents: {
registerConsent: 'MARKETING_NEWSLETTER',
showLegalDescriptionInDialog: true,
requiredConsents: [],
consentManagementPage: {
showAnonymousConsents: true,
hideConsents: [],
},
},
};
exports.CountryType = void 0;
(function (CountryType) {
CountryType["BILLING"] = "BILLING";
CountryType["SHIPPING"] = "SHIPPING";
})(exports.CountryType || (exports.CountryType = {}));
exports.PromotionLocation = void 0;
(function (PromotionLocation) {
PromotionLocation["ActiveCart"] = "CART";
PromotionLocation["Checkout"] = "CHECKOUT";
PromotionLocation["Order"] = "ORDER";
PromotionLocation["SaveForLater"] = "SAVE_FOR_LATER";
PromotionLocation["SavedCart"] = "SAVED_CART";
})(exports.PromotionLocation || (exports.PromotionLocation = {}));
exports.B2BPaymentTypeEnum = void 0;
(function (B2BPaymentTypeEnum) {
B2BPaymentTypeEnum["ACCOUNT_PAYMENT"] = "ACCOUNT";
B2BPaymentTypeEnum["CARD_PAYMENT"] = "CARD";
})(exports.B2BPaymentTypeEnum || (exports.B2BPaymentTypeEnum = {}));
exports.CartValidationStatusCode = void 0;
(function (CartValidationStatusCode) {
CartValidationStatusCode["NO_STOCK"] = "noStock";
CartValidationStatusCode["LOW_STOCK"] = "lowStock";
CartValidationStatusCode["REVIEW_CONFIGURATION"] = "reviewConfiguration";
CartValidationStatusCode["PRICING_ERROR"] = "pricingError";
CartValidationStatusCode["UNRESOLVABLE_ISSUES"] = "unresolvableIssues";
})(exports.CartValidationStatusCode || (exports.CartValidationStatusCode = {}));
exports.PageType = void 0;
(function (PageType) {
PageType["CONTENT_PAGE"] = "ContentPage";
PageType["PRODUCT_PAGE"] = "ProductPage";
PageType["CATEGORY_PAGE"] = "CategoryPage";
PageType["CATALOG_PAGE"] = "CatalogPage";
})(exports.PageType || (exports.PageType = {}));
exports.CmsBannerCarouselEffect = void 0;
(function (CmsBannerCarouselEffect) {
CmsBannerCarouselEffect["FADE"] = "FADE";
CmsBannerCarouselEffect["ZOOM"] = "ZOOM";
CmsBannerCarouselEffect["CURTAIN"] = "CURTAINX";
CmsBannerCarouselEffect["TURNDOWN"] = "TURNDOWN";
})(exports.CmsBannerCarouselEffect || (exports.CmsBannerCarouselEffect = {}));
exports.ANONYMOUS_CONSENT_STATUS = void 0;
(function (ANONYMOUS_CONSENT_STATUS) {
ANONYMOUS_CONSENT_STATUS["GIVEN"] = "GIVEN";
ANONYMOUS_CONSENT_STATUS["WITHDRAWN"] = "WITHDRAWN";
})(exports.ANONYMOUS_CONSENT_STATUS || (exports.ANONYMOUS_CONSENT_STATUS = {}));
var ANONYMOUS_CONSENTS_HEADER = 'X-Anonymous-Consents';
exports.ImageType = void 0;
(function (ImageType) {
ImageType["PRIMARY"] = "PRIMARY";
ImageType["GALLERY"] = "GALLERY";
})(exports.ImageType || (exports.ImageType = {}));
var HttpErrorModel = /** @class */ (function () {
function HttpErrorModel() {
}
return HttpErrorModel;
}());
exports.B2BUserRole = void 0;
(function (B2BUserRole) {
B2BUserRole["ADMIN"] = "b2badmingroup";
B2BUserRole["CUSTOMER"] = "b2bcustomergroup";
B2BUserRole["MANAGER"] = "b2bmanagergroup";
B2BUserRole["APPROVER"] = "b2bapprovergroup";
})(exports.B2BUserRole || (exports.B2BUserRole = {}));
exports.NotificationType = void 0;
(function (NotificationType) {
NotificationType["BACK_IN_STOCK"] = "BACK_IN_STOCK";
})(exports.NotificationType || (exports.NotificationType = {}));
exports.VariantType = void 0;
(function (VariantType) {
VariantType["SIZE"] = "ApparelSizeVariantProduct";
VariantType["STYLE"] = "ApparelStyleVariantProduct";
VariantType["COLOR"] = "ElectronicsColorVariantProduct";
})(exports.VariantType || (exports.VariantType = {}));
exports.PriceType = void 0;
(function (PriceType) {
PriceType["BUY"] = "BUY";
PriceType["FROM"] = "FROM";
})(exports.PriceType || (exports.PriceType = {}));
exports.VariantQualifier = void 0;
(function (VariantQualifier) {
VariantQualifier["SIZE"] = "size";
VariantQualifier["STYLE"] = "style";
VariantQualifier["COLOR"] = "color";
VariantQualifier["THUMBNAIL"] = "thumbnail";
VariantQualifier["PRODUCT"] = "product";
VariantQualifier["ROLLUP_PROPERTY"] = "rollupProperty";
})(exports.VariantQualifier || (exports.VariantQualifier = {}));
exports.DaysOfWeek = void 0;
(function (DaysOfWeek) {
DaysOfWeek["MONDAY"] = "MONDAY";
DaysOfWeek["TUESDAY"] = "TUESDAY";
DaysOfWeek["WEDNESDAY"] = "WEDNESDAY";
DaysOfWeek["THURSDAY"] = "THURSDAY";
DaysOfWeek["FRIDAY"] = "FRIDAY";
DaysOfWeek["SATURDAY"] = "SATURDAY";
DaysOfWeek["SUNDAY"] = "SUNDAY";
})(exports.DaysOfWeek || (exports.DaysOfWeek = {}));
var recurrencePeriod = {
DAILY: 'DAILY',
WEEKLY: 'WEEKLY',
MONTHLY: 'MONTHLY',
};
exports.ORDER_TYPE = void 0;
(function (ORDER_TYPE) {
ORDER_TYPE["PLACE_ORDER"] = "PLACE_ORDER";
ORDER_TYPE["SCHEDULE_REPLENISHMENT_ORDER"] = "SCHEDULE_REPLENISHMENT_ORDER";
})(exports.ORDER_TYPE || (exports.ORDER_TYPE = {}));
var ENTITY_REMOVE_ACTION = '[ENTITY] REMOVE';
var ENTITY_REMOVE_ALL_ACTION = '[ENTITY] REMOVE ALL';
function entityMeta(type, id) {
return {
entityType: type,
entityId: id,
};
}
function entityRemoveMeta(type, id) {
return {
entityId: id,
entityType: type,
entityRemove: true,
};
}
function entityRemoveAllMeta(type) {
return {
entityId: null,
entityType: type,
entityRemove: true,
};
}
var EntityRemoveAction = /** @class */ (function () {
function EntityRemoveAction(entityType, id) {
this.type = ENTITY_REMOVE_ACTION;
this.meta = entityRemoveMeta(entityType, id);
}
return EntityRemoveAction;
}());
var EntityRemoveAllAction = /** @class */ (function () {
function EntityRemoveAllAction(entityType) {
this.type = ENTITY_REMOVE_ALL_ACTION;
this.meta = entityRemoveAllMeta(entityType);
}
return EntityRemoveAllAction;
}());
var LOADER_LOAD_ACTION = '[LOADER] LOAD';
var LOADER_FAIL_ACTION = '[LOADER] FAIL';
var LOADER_SUCCESS_ACTION = '[LOADER] SUCCESS';
var LOADER_RESET_ACTION = '[LOADER] RESET';
function loadMeta(entityType) {
return {
entityType: entityType,
loader: {
load: true,
},
};
}
function failMeta(entityType, error) {
return {
entityType: entityType,
loader: {
error: error ? error : true,
},
};
}
function successMeta(entityType) {
return {
entityType: entityType,
loader: {
success: true,
},
};
}
function resetMeta(entityType) {
return {
entityType: entityType,
loader: {},
};
}
var LoaderLoadAction = /** @class */ (function () {
function LoaderLoadAction(entityType) {
this.type = LOADER_LOAD_ACTION;
this.meta = loadMeta(entityType);
}
return LoaderLoadAction;
}());
var LoaderFailAction = /** @class */ (function () {
function LoaderFailAction(entityType, error) {
this.type = LOADER_FAIL_ACTION;
this.meta = failMeta(entityType, error);
}
return LoaderFailAction;
}());
var LoaderSuccessAction = /** @class */ (function () {
function LoaderSuccessAction(entityType) {
this.type = LOADER_SUCCESS_ACTION;
this.meta = successMeta(entityType);
}
return LoaderSuccessAction;
}());
var LoaderResetAction = /** @class */ (function () {
function LoaderResetAction(entityType) {
this.type = LOADER_RESET_ACTION;
this.meta = resetMeta(entityType);
}
return LoaderResetAction;
}());
var ENTITY_LOAD_ACTION = '[ENTITY] LOAD';
var ENTITY_FAIL_ACTION = '[ENTITY] LOAD FAIL';
var ENTITY_SUCCESS_ACTION = '[ENTITY] LOAD SUCCESS';
var ENTITY_RESET_ACTION = '[ENTITY] RESET';
function entityLoadMeta(entityType, id) {
return Object.assign(Object.assign({}, loadMeta(entityType)), entityMeta(entityType, id));
}
function entityFailMeta(entityType, id, error) {
return Object.assign(Object.assign({}, failMeta(entityType, error)), entityMeta(entityType, id));
}
function entitySuccessMeta(entityType, id) {
return Object.assign(Object.assign({}, successMeta(entityType)), entityMeta(entityType, id));
}
function entityResetMeta(entityType, id) {
return Object.assign(Object.assign({}, resetMeta(entityType)), entityMeta(entityType, id));
}
var EntityLoadAction = /** @class */ (function () {
function EntityLoadAction(entityType, id) {
this.type = ENTITY_LOAD_ACTION;
this.meta = entityLoadMeta(entityType, id);
}
return EntityLoadAction;
}());
var EntityFailAction = /** @class */ (function () {
function EntityFailAction(entityType, id, error) {
this.type = ENTITY_FAIL_ACTION;
this.meta = entityFailMeta(entityType, id, error);
}
return EntityFailAction;
}());
var EntitySuccessAction = /** @class */ (function () {
function EntitySuccessAction(entityType, id, payload) {
this.payload = payload;
this.type = ENTITY_SUCCESS_ACTION;
this.meta = entitySuccessMeta(entityType, id);
}
return EntitySuccessAction;
}());
var EntityLoaderResetAction = /** @class */ (function () {
function EntityLoaderResetAction(entityType, id) {
this.type = ENTITY_RESET_ACTION;
this.meta = entityResetMeta(entityType, id);
}
return EntityLoaderResetAction;
}());
var initialLoaderState = {
loading: false,
error: false,
success: false,
value: undefined,
};
/**
* Higher order reducer that adds generic loading flag to chunk of the state
*
* Utilizes "loader" meta field of actions to set specific flags for specific
* action (LOAD, SUCCESS, FAIL, RESET)
*/
function loaderReducer(entityType, reducer) {
return function (state, action) {
if (state === void 0) { state = initialLoaderState; }
if (action.meta &&
action.meta.loader &&
action.meta.entityType === entityType) {
var entity = action.meta.loader;
if (entity.load) {
return Object.assign(Object.assign({}, state), { loading: true, value: reducer ? reducer(state.value, action) : state.value });
}
else if (entity.error) {
return Object.assign(Object.assign({}, state), { loading: false, error: true, success: false, value: reducer ? reducer(state.value, action) : undefined });
}
else if (entity.success) {
return Object.assign(Object.assign({}, state), { value: reducer ? reducer(state.value, action) : action.payload, loading: false, error: false, success: true });
}
else {
// reset state action
return Object.assign(Object.assign({}, initialLoaderState), { value: reducer
? reducer(initialLoaderState.value, action)
: initialLoaderState.value });
}
}
if (reducer) {
var newValue = reducer(state.value, action);
if (newValue !== state.value) {
return Object.assign(Object.assign({}, state), { value: newValue });
}
}
return state;
};
}
function loaderValueSelector(state) {
return state.value;
}
function loaderLoadingSelector(state) {
return state.loading;
}
function loaderErrorSelector(state) {
return state.error;
}
function loaderSuccessSelector(state) {
return state.success;
}
function entityLoaderStateSelector(state, id) {
return state.entities[id] || initialLoaderState;
}
function entityValueSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return loaderValueSelector(entityState);
}
function entityLoadingSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return loaderLoadingSelector(entityState);
}
function entityErrorSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return loaderErrorSelector(entityState);
}
function entitySuccessSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return loaderSuccessSelector(entityState);
}
var initialEntityState = { entities: {} };
/**
* Higher order reducer for reusing reducer logic for multiple entities
*
* Utilizes entityId meta field to target entity by id in actions
*/
function entityReducer(entityType, reducer) {
return function (state, action) {
if (state === void 0) { state = initialEntityState; }
var ids;
var partitionPayload = false;
if (action.meta &&
action.meta.entityType === entityType &&
action.meta.entityId !== undefined) {
ids = [].concat(action.meta.entityId);
// remove selected entities
if (action.meta.entityRemove) {
if (action.meta.entityId === null) {
return initialEntityState;
}
else {
var removed_1 = false;
var newEntities = Object.keys(state.entities).reduce(function (acc, cur) {
if (ids.includes(cur)) {
removed_1 = true;
}
else {
acc[cur] = state.entities[cur];
}
return acc;
}, {});
return removed_1 ? { entities: newEntities } : state;
}
}
partitionPayload =
Array.isArray(action.meta.entityId) && Array.isArray(action.payload);
}
else {
ids = Object.keys(state.entities);
}
var entityUpdates = {};
for (var i = 0; i < ids.length; i++) {
var id = ids[i];
var subAction = partitionPayload
? Object.assign(Object.assign({}, action), { payload: action.payload[i] }) : action;
var newState = reducer(state.entities[id], subAction);
if (newState) {
entityUpdates[id] = newState;
}
}
if (Object.keys(entityUpdates).length > 0) {
return Object.assign(Object.assign({}, state), { entities: Object.assign(Object.assign({}, state.entities), entityUpdates) });
}
return state;
};
}
/**
* Higher order reducer that wraps LoaderReducer and EntityReducer enhancing
* single state reducer to support multiple entities with generic loading flags
*/
function entityLoaderReducer(entityType, reducer) {
return entityReducer(entityType, loaderReducer(entityType, reducer));
}
var PROCESSES_INCREMENT_ACTION = '[PROCESSES LOADER] INCREMENT';
var PROCESSES_DECREMENT_ACTION = '[PROCESSES LOADER] DECREMENT';
var PROCESSES_LOADER_RESET_ACTION = '[PROCESSES LOADER] RESET';
function processesIncrementMeta(entityType) {
return {
entityType: entityType,
loader: undefined,
processesCountDiff: 1,
};
}
function processesDecrementMeta(entityType) {
return {
entityType: entityType,
loader: undefined,
processesCountDiff: -1,
};
}
function processesLoaderResetMeta(entityType) {
// processes reset action is a reset action for loader reducer, but not the other way around
return Object.assign(Object.assign({}, resetMeta(entityType)), { processesCountDiff: null });
}
var ProcessesLoaderResetAction = /** @class */ (function () {
function ProcessesLoaderResetAction(entityType) {
this.type = PROCESSES_LOADER_RESET_ACTION;
this.meta = processesLoaderResetMeta(entityType);
}
return ProcessesLoaderResetAction;
}());
var ProcessesIncrementAction = /** @class */ (function () {
function ProcessesIncrementAction(entityType) {
this.type = PROCESSES_INCREMENT_ACTION;
this.meta = processesIncrementMeta(entityType);
}
return ProcessesIncrementAction;
}());
var ProcessesDecrementAction = /** @class */ (function () {
function ProcessesDecrementAction(entityType) {
this.type = PROCESSES_DECREMENT_ACTION;
this.meta = processesDecrementMeta(entityType);
}
return ProcessesDecrementAction;
}());
var ENTITY_PROCESSES_LOADER_RESET_ACTION = '[ENTITY] PROCESSES LOADER RESET';
var ENTITY_PROCESSES_INCREMENT_ACTION = '[ENTITY] PROCESSES INCREMENT';
var ENTITY_PROCESSES_DECREMENT_ACTION = '[ENTITY] PROCESSES DECREMENT';
function entityProcessesLoaderResetMeta(entityType, id) {
return Object.assign(Object.assign({}, processesLoaderResetMeta(entityType)), entityMeta(entityType, id));
}
function entityProcessesIncrementMeta(entityType, id) {
return Object.assign(Object.assign({}, processesIncrementMeta(entityType)), entityMeta(entityType, id));
}
function entityProcessesDecrementMeta(entityType, id) {
return Object.assign(Object.assign({}, processesDecrementMeta(entityType)), entityMeta(entityType, id));
}
var EntityProcessesLoaderResetAction = /** @class */ (function () {
function EntityProcessesLoaderResetAction(entityType, id) {
this.type = ENTITY_PROCESSES_LOADER_RESET_ACTION;
this.meta = entityProcessesLoaderResetMeta(entityType, id);
}
return EntityProcessesLoaderResetAction;
}());
var EntityProcessesIncrementAction = /** @class */ (function () {
function EntityProcessesIncrementAction(entityType, id) {
this.type = ENTITY_PROCESSES_INCREMENT_ACTION;
this.meta = entityProcessesIncrementMeta(entityType, id);
}
return EntityProcessesIncrementAction;
}());
var EntityProcessesDecrementAction = /** @class */ (function () {
function EntityProcessesDecrementAction(entityType, id) {
this.type = ENTITY_PROCESSES_DECREMENT_ACTION;
this.meta = entityProcessesDecrementMeta(entityType, id);
}
return EntityProcessesDecrementAction;
}());
function isStableSelector(state) {
return state.processesCount === 0 && !state.loading;
}
function hasPendingProcessesSelector(state) {
return state.processesCount > 0;
}
var initialProcessesState = {
processesCount: 0,
};
/**
* Higher order reducer that adds processes count
*/
function processesLoaderReducer(entityType, reducer) {
return function (state, action) {
if (state === void 0) { state = Object.assign(Object.assign({}, initialProcessesState), initialLoaderState); }
var loaderState = loaderReducer(entityType, reducer)(state, action);
if (action.meta && action.meta.entityType === entityType) {
var processesCountDiff = action.meta.processesCountDiff;
if (i0.isDevMode() && state.processesCount + processesCountDiff < 0) {
console.error("Action '" + action.type + "' sets processesCount to value < 0!\n" +
'Make sure to keep processesCount in sync.\n' +
'There should always be only one decrement action for each increment action.\n' +
"Make sure that you don't reset state in between those actions.\n", action);
}
if (processesCountDiff) {
return Object.assign(Object.assign({}, loaderState), { processesCount: state.processesCount
? state.processesCount + processesCountDiff
: processesCountDiff });
}
else if (processesCountDiff === null) {
// reset action
return Object.assign(Object.assign({}, loaderState), initialProcessesState);
}
}
return loaderState;
};
}
var initialProcessesLoaderState = Object.assign(Object.assign({}, initialLoaderState), initialProcessesState);
function entityHasPendingProcessesSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return hasPendingProcessesSelector(entityState);
}
function entityIsStableSelector(state, id) {
var entityState = entityLoaderStateSelector(state, id);
return isStableSelector(entityState);
}
function entityProcessesLoaderStateSelector(state, id) {
return state.entities[id] || initialProcessesLoaderState;
}
/**
* Higher order reducer that wraps ProcessesLoaderReducer and EntityReducer enhancing
* single state reducer to support multiple entities with generic processesCount flag
*/
function entityProcessesLoaderReducer(entityType, reducer) {
return entityReducer(entityType, processesLoaderReducer(entityType, reducer));
}
function entitySelector(state, id) {
return state.entities[id] || undefined;
}
var OBJECT_SEPARATOR = '.';
function getStateSliceValue(keys, state) {
return keys
.split(OBJECT_SEPARATOR)
.reduce(function (previous, current) { return (previous ? previous[current] : undefined); }, state);
}
function createShellObject(key, excludeKeys, value) {
if (!key || !value || Object.keys(value).length === 0) {
return {};
}
var shell = key.split(OBJECT_SEPARATOR).reduceRight(function (acc, previous) {
var _a;
return _a = {}, _a[previous] = acc, _a;
}, value);
return handleExclusions(key, excludeKeys, shell);
}
function getStateSlice(keys, excludeKeys, state) {
var e_1, _a;
if (keys && keys.length === 0) {
return {};
}
var stateSlices = {};
try {
for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
var currentKey = keys_1_1.value;
var stateValue = getStateSliceValue(currentKey, state);
var shell = createShellObject(currentKey, excludeKeys, stateValue);
stateSlices = deepMerge(stateSlices, shell);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
}
finally { if (e_1) throw e_1.error; }
}
return stateSlices;
}
function handleExclusions(key, excludeKeys, value) {
var e_2, _a;
var exclusionKeys = getExclusionKeys(key, excludeKeys);
if (exclusionKeys.length === 0) {
return value;
}
var finalValue = deepMerge({}, value);
try {
for (var exclusionKeys_1 = __values(exclusionKeys), exclusionKeys_1_1 = exclusionKeys_1.next(); !exclusionKeys_1_1.done; exclusionKeys_1_1 = exclusionKeys_1.next()) {
var currentExclusionKey = exclusionKeys_1_1.value;
var exclusionChunksSplit = currentExclusionKey.split(OBJECT_SEPARATOR);
var nestedTemp = finalValue;
for (var i = 0; i < exclusionChunksSplit.length; i++) {
var currentChunk = exclusionChunksSplit[i];
// last iteration
if (i === exclusionChunksSplit.length - 1) {
if (nestedTemp && nestedTemp[currentChunk]) {
delete nestedTemp[currentChunk];
}
}
else {
nestedTemp = nestedTemp[currentChunk];
}
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (exclusionKeys_1_1 && !exclusionKeys_1_1.done && (_a = exclusionKeys_1.return)) _a.call(exclusionKeys_1);
}
finally { if (e_2) throw e_2.error; }
}
return finalValue;
}
function getExclusionKeys(key, excludeKeys) {
var e_3, _a;
if (!key || !excludeKeys) {
return [];
}
var exclusionKeys = [];
try {
for (var excludeKeys_1 = __values(excludeKeys), excludeKeys_1_1 = excludeKeys_1.next(); !excludeKeys_1_1.done; excludeKeys_1_1 = excludeKeys_1.next()) {
var exclusionKey = excludeKeys_1_1.value;
if (exclusionKey.includes(key)) {
exclusionKeys.push(exclusionKey);
}
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (excludeKeys_1_1 && !excludeKeys_1_1.done && (_a = excludeKeys_1.return)) _a.call(excludeKeys_1);
}
finally { if (e_3) throw e_3.error; }
}
return exclusionKeys;
}
function filterKeysByType(keys, type) {
if (!keys) {
return [];
}
return Object.keys(keys).filter(function (key) { return keys[key] === type; });
}
var ALL = 'all';
function serializeSearchConfig(config, id) {
var