@vendure/admin-ui 1.4.7 → 2.0.0-next.0

package/esm2020/core/common/introspection-result.mjs

@@ -0,0 +1,187 @@
+// tslint:disable
+const result = {
+    possibleTypes: {
+        AddFulfillmentToOrderResult: [
+            'CreateFulfillmentError',
+            'EmptyOrderLineSelectionError',
+            'Fulfillment',
+            'FulfillmentStateTransitionError',
+            'InsufficientStockOnHandError',
+            'InvalidFulfillmentHandlerError',
+            'ItemsAlreadyFulfilledError',
+        ],
+        AddManualPaymentToOrderResult: ['ManualPaymentStateError', 'Order'],
+        AuthenticationResult: ['CurrentUser', 'InvalidCredentialsError'],
+        CancelOrderResult: [
+            'CancelActiveOrderError',
+            'EmptyOrderLineSelectionError',
+            'MultipleOrderError',
+            'Order',
+            'OrderStateTransitionError',
+            'QuantityTooGreatError',
+        ],
+        CreateAssetResult: ['Asset', 'MimeTypeError'],
+        CreateChannelResult: ['Channel', 'LanguageNotAvailableError'],
+        CreateCustomerResult: ['Customer', 'EmailAddressConflictError'],
+        CreatePromotionResult: ['MissingConditionsError', 'Promotion'],
+        CustomField: [
+            'BooleanCustomFieldConfig',
+            'DateTimeCustomFieldConfig',
+            'FloatCustomFieldConfig',
+            'IntCustomFieldConfig',
+            'LocaleStringCustomFieldConfig',
+            'RelationCustomFieldConfig',
+            'StringCustomFieldConfig',
+            'TextCustomFieldConfig',
+        ],
+        CustomFieldConfig: [
+            'BooleanCustomFieldConfig',
+            'DateTimeCustomFieldConfig',
+            'FloatCustomFieldConfig',
+            'IntCustomFieldConfig',
+            'LocaleStringCustomFieldConfig',
+            'RelationCustomFieldConfig',
+            'StringCustomFieldConfig',
+            'TextCustomFieldConfig',
+        ],
+        ErrorResult: [
+            'AlreadyRefundedError',
+            'CancelActiveOrderError',
+            'ChannelDefaultLanguageError',
+            'CreateFulfillmentError',
+            'EmailAddressConflictError',
+            'EmptyOrderLineSelectionError',
+            'FulfillmentStateTransitionError',
+            'InsufficientStockError',
+            'InsufficientStockOnHandError',
+            'InvalidCredentialsError',
+            'InvalidFulfillmentHandlerError',
+            'ItemsAlreadyFulfilledError',
+            'LanguageNotAvailableError',
+            'ManualPaymentStateError',
+            'MimeTypeError',
+            'MissingConditionsError',
+            'MultipleOrderError',
+            'NativeAuthStrategyError',
+            'NegativeQuantityError',
+            'NoChangesSpecifiedError',
+            'NothingToRefundError',
+            'OrderLimitError',
+            'OrderModificationStateError',
+            'OrderStateTransitionError',
+            'PaymentMethodMissingError',
+            'PaymentOrderMismatchError',
+            'PaymentStateTransitionError',
+            'ProductOptionInUseError',
+            'QuantityTooGreatError',
+            'RefundOrderStateError',
+            'RefundPaymentIdMissingError',
+            'RefundStateTransitionError',
+            'SettlePaymentError',
+        ],
+        ModifyOrderResult: [
+            'InsufficientStockError',
+            'NegativeQuantityError',
+            'NoChangesSpecifiedError',
+            'Order',
+            'OrderLimitError',
+            'OrderModificationStateError',
+            'PaymentMethodMissingError',
+            'RefundPaymentIdMissingError',
+        ],
+        NativeAuthenticationResult: ['CurrentUser', 'InvalidCredentialsError', 'NativeAuthStrategyError'],
+        Node: [
+            'Address',
+            'Administrator',
+            'Allocation',
+            'Asset',
+            'AuthenticationMethod',
+            'Cancellation',
+            'Channel',
+            'Collection',
+            'Country',
+            'Customer',
+            'CustomerGroup',
+            'Facet',
+            'FacetValue',
+            'Fulfillment',
+            'HistoryEntry',
+            'Job',
+            'Order',
+            'OrderItem',
+            'OrderLine',
+            'OrderModification',
+            'Payment',
+            'PaymentMethod',
+            'Product',
+            'ProductOption',
+            'ProductOptionGroup',
+            'ProductVariant',
+            'Promotion',
+            'Refund',
+            'Release',
+            'Return',
+            'Role',
+            'Sale',
+            'ShippingMethod',
+            'StockAdjustment',
+            'Surcharge',
+            'Tag',
+            'TaxCategory',
+            'TaxRate',
+            'User',
+            'Zone',
+        ],
+        PaginatedList: [
+            'AdministratorList',
+            'AssetList',
+            'CollectionList',
+            'CountryList',
+            'CustomerGroupList',
+            'CustomerList',
+            'FacetList',
+            'HistoryEntryList',
+            'JobList',
+            'OrderList',
+            'PaymentMethodList',
+            'ProductList',
+            'ProductVariantList',
+            'PromotionList',
+            'RoleList',
+            'ShippingMethodList',
+            'TagList',
+            'TaxRateList',
+        ],
+        RefundOrderResult: [
+            'AlreadyRefundedError',
+            'MultipleOrderError',
+            'NothingToRefundError',
+            'OrderStateTransitionError',
+            'PaymentOrderMismatchError',
+            'QuantityTooGreatError',
+            'Refund',
+            'RefundOrderStateError',
+            'RefundStateTransitionError',
+        ],
+        RemoveOptionGroupFromProductResult: ['Product', 'ProductOptionInUseError'],
+        SearchResultPrice: ['PriceRange', 'SinglePrice'],
+        SettlePaymentResult: [
+            'OrderStateTransitionError',
+            'Payment',
+            'PaymentStateTransitionError',
+            'SettlePaymentError',
+        ],
+        SettleRefundResult: ['Refund', 'RefundStateTransitionError'],
+        StockMovement: ['Allocation', 'Cancellation', 'Release', 'Return', 'Sale', 'StockAdjustment'],
+        StockMovementItem: ['Allocation', 'Cancellation', 'Release', 'Return', 'Sale', 'StockAdjustment'],
+        TransitionFulfillmentToStateResult: ['Fulfillment', 'FulfillmentStateTransitionError'],
+        TransitionOrderToStateResult: ['Order', 'OrderStateTransitionError'],
+        TransitionPaymentToStateResult: ['Payment', 'PaymentStateTransitionError'],
+        UpdateChannelResult: ['Channel', 'LanguageNotAvailableError'],
+        UpdateCustomerResult: ['Customer', 'EmailAddressConflictError'],
+        UpdateGlobalSettingsResult: ['ChannelDefaultLanguageError', 'GlobalSettings'],
+        UpdatePromotionResult: ['MissingConditionsError', 'Promotion'],
+    },
+};
+export default result;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"introspection-result.js","sourceRoot":"","sources":["../../../../src/lib/core/src/common/introspection-result.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable\r\n\r\nexport interface PossibleTypesResultData {\r\n    possibleTypes: {\r\n        [key: string]: string[];\r\n    };\r\n}\r\nconst result: PossibleTypesResultData = {\r\n    possibleTypes: {\r\n        AddFulfillmentToOrderResult: [\r\n            'CreateFulfillmentError',\r\n            'EmptyOrderLineSelectionError',\r\n            'Fulfillment',\r\n            'FulfillmentStateTransitionError',\r\n            'InsufficientStockOnHandError',\r\n            'InvalidFulfillmentHandlerError',\r\n            'ItemsAlreadyFulfilledError',\r\n        ],\r\n        AddManualPaymentToOrderResult: ['ManualPaymentStateError', 'Order'],\r\n        AuthenticationResult: ['CurrentUser', 'InvalidCredentialsError'],\r\n        CancelOrderResult: [\r\n            'CancelActiveOrderError',\r\n            'EmptyOrderLineSelectionError',\r\n            'MultipleOrderError',\r\n            'Order',\r\n            'OrderStateTransitionError',\r\n            'QuantityTooGreatError',\r\n        ],\r\n        CreateAssetResult: ['Asset', 'MimeTypeError'],\r\n        CreateChannelResult: ['Channel', 'LanguageNotAvailableError'],\r\n        CreateCustomerResult: ['Customer', 'EmailAddressConflictError'],\r\n        CreatePromotionResult: ['MissingConditionsError', 'Promotion'],\r\n        CustomField: [\r\n            'BooleanCustomFieldConfig',\r\n            'DateTimeCustomFieldConfig',\r\n            'FloatCustomFieldConfig',\r\n            'IntCustomFieldConfig',\r\n            'LocaleStringCustomFieldConfig',\r\n            'RelationCustomFieldConfig',\r\n            'StringCustomFieldConfig',\r\n            'TextCustomFieldConfig',\r\n        ],\r\n        CustomFieldConfig: [\r\n            'BooleanCustomFieldConfig',\r\n            'DateTimeCustomFieldConfig',\r\n            'FloatCustomFieldConfig',\r\n            'IntCustomFieldConfig',\r\n            'LocaleStringCustomFieldConfig',\r\n            'RelationCustomFieldConfig',\r\n            'StringCustomFieldConfig',\r\n            'TextCustomFieldConfig',\r\n        ],\r\n        ErrorResult: [\r\n            'AlreadyRefundedError',\r\n            'CancelActiveOrderError',\r\n            'ChannelDefaultLanguageError',\r\n            'CreateFulfillmentError',\r\n            'EmailAddressConflictError',\r\n            'EmptyOrderLineSelectionError',\r\n            'FulfillmentStateTransitionError',\r\n            'InsufficientStockError',\r\n            'InsufficientStockOnHandError',\r\n            'InvalidCredentialsError',\r\n            'InvalidFulfillmentHandlerError',\r\n            'ItemsAlreadyFulfilledError',\r\n            'LanguageNotAvailableError',\r\n            'ManualPaymentStateError',\r\n            'MimeTypeError',\r\n            'MissingConditionsError',\r\n            'MultipleOrderError',\r\n            'NativeAuthStrategyError',\r\n            'NegativeQuantityError',\r\n            'NoChangesSpecifiedError',\r\n            'NothingToRefundError',\r\n            'OrderLimitError',\r\n            'OrderModificationStateError',\r\n            'OrderStateTransitionError',\r\n            'PaymentMethodMissingError',\r\n            'PaymentOrderMismatchError',\r\n            'PaymentStateTransitionError',\r\n            'ProductOptionInUseError',\r\n            'QuantityTooGreatError',\r\n            'RefundOrderStateError',\r\n            'RefundPaymentIdMissingError',\r\n            'RefundStateTransitionError',\r\n            'SettlePaymentError',\r\n        ],\r\n        ModifyOrderResult: [\r\n            'InsufficientStockError',\r\n            'NegativeQuantityError',\r\n            'NoChangesSpecifiedError',\r\n            'Order',\r\n            'OrderLimitError',\r\n            'OrderModificationStateError',\r\n            'PaymentMethodMissingError',\r\n            'RefundPaymentIdMissingError',\r\n        ],\r\n        NativeAuthenticationResult: ['CurrentUser', 'InvalidCredentialsError', 'NativeAuthStrategyError'],\r\n        Node: [\r\n            'Address',\r\n            'Administrator',\r\n            'Allocation',\r\n            'Asset',\r\n            'AuthenticationMethod',\r\n            'Cancellation',\r\n            'Channel',\r\n            'Collection',\r\n            'Country',\r\n            'Customer',\r\n            'CustomerGroup',\r\n            'Facet',\r\n            'FacetValue',\r\n            'Fulfillment',\r\n            'HistoryEntry',\r\n            'Job',\r\n            'Order',\r\n            'OrderItem',\r\n            'OrderLine',\r\n            'OrderModification',\r\n            'Payment',\r\n            'PaymentMethod',\r\n            'Product',\r\n            'ProductOption',\r\n            'ProductOptionGroup',\r\n            'ProductVariant',\r\n            'Promotion',\r\n            'Refund',\r\n            'Release',\r\n            'Return',\r\n            'Role',\r\n            'Sale',\r\n            'ShippingMethod',\r\n            'StockAdjustment',\r\n            'Surcharge',\r\n            'Tag',\r\n            'TaxCategory',\r\n            'TaxRate',\r\n            'User',\r\n            'Zone',\r\n        ],\r\n        PaginatedList: [\r\n            'AdministratorList',\r\n            'AssetList',\r\n            'CollectionList',\r\n            'CountryList',\r\n            'CustomerGroupList',\r\n            'CustomerList',\r\n            'FacetList',\r\n            'HistoryEntryList',\r\n            'JobList',\r\n            'OrderList',\r\n            'PaymentMethodList',\r\n            'ProductList',\r\n            'ProductVariantList',\r\n            'PromotionList',\r\n            'RoleList',\r\n            'ShippingMethodList',\r\n            'TagList',\r\n            'TaxRateList',\r\n        ],\r\n        RefundOrderResult: [\r\n            'AlreadyRefundedError',\r\n            'MultipleOrderError',\r\n            'NothingToRefundError',\r\n            'OrderStateTransitionError',\r\n            'PaymentOrderMismatchError',\r\n            'QuantityTooGreatError',\r\n            'Refund',\r\n            'RefundOrderStateError',\r\n            'RefundStateTransitionError',\r\n        ],\r\n        RemoveOptionGroupFromProductResult: ['Product', 'ProductOptionInUseError'],\r\n        SearchResultPrice: ['PriceRange', 'SinglePrice'],\r\n        SettlePaymentResult: [\r\n            'OrderStateTransitionError',\r\n            'Payment',\r\n            'PaymentStateTransitionError',\r\n            'SettlePaymentError',\r\n        ],\r\n        SettleRefundResult: ['Refund', 'RefundStateTransitionError'],\r\n        StockMovement: ['Allocation', 'Cancellation', 'Release', 'Return', 'Sale', 'StockAdjustment'],\r\n        StockMovementItem: ['Allocation', 'Cancellation', 'Release', 'Return', 'Sale', 'StockAdjustment'],\r\n        TransitionFulfillmentToStateResult: ['Fulfillment', 'FulfillmentStateTransitionError'],\r\n        TransitionOrderToStateResult: ['Order', 'OrderStateTransitionError'],\r\n        TransitionPaymentToStateResult: ['Payment', 'PaymentStateTransitionError'],\r\n        UpdateChannelResult: ['Channel', 'LanguageNotAvailableError'],\r\n        UpdateCustomerResult: ['Customer', 'EmailAddressConflictError'],\r\n        UpdateGlobalSettingsResult: ['ChannelDefaultLanguageError', 'GlobalSettings'],\r\n        UpdatePromotionResult: ['MissingConditionsError', 'Promotion'],\r\n    },\r\n};\r\nexport default result;\r\n"]}

package/esm2020/core/common/utilities/configurable-operation-utils.mjs

@@ -0,0 +1,83 @@
+/**
+ * ConfigArg values are always stored as strings. If they are not primitives, then
+ * they are JSON-encoded. This function unwraps them back into their original
+ * data type.
+ */
+export function getConfigArgValue(value) {
+    try {
+        return value ? JSON.parse(value) : undefined;
+    }
+    catch (e) {
+        return value;
+    }
+}
+export function encodeConfigArgValue(value) {
+    return Array.isArray(value) ? JSON.stringify(value) : (value ?? '').toString();
+}
+/**
+ * Creates an empty ConfigurableOperation object based on the definition.
+ */
+export function configurableDefinitionToInstance(def) {
+    return {
+        ...def,
+        args: def.args.map(arg => {
+            return {
+                ...arg,
+                value: getDefaultConfigArgValue(arg),
+            };
+        }),
+    };
+}
+/**
+ * Converts an object of the type:
+ * ```
+ * {
+ *     code: 'my-operation',
+ *     args: {
+ *         someProperty: 'foo'
+ *     }
+ * }
+ * ```
+ * to the format defined by the ConfigurableOperationInput GraphQL input type:
+ * ```
+ * {
+ *     code: 'my-operation',
+ *     args: [
+ *         { name: 'someProperty', value: 'foo' }
+ *     ]
+ * }
+ * ```
+ */
+export function toConfigurableOperationInput(operation, formValueOperations) {
+    return {
+        code: operation.code,
+        arguments: Object.values(formValueOperations.args || {}).map((value, j) => ({
+            name: operation.args[j].name,
+            value: value.hasOwnProperty('value')
+                ? encodeConfigArgValue(value.value)
+                : encodeConfigArgValue(value),
+        })),
+    };
+}
+export function configurableOperationValueIsValid(def, value) {
+    if (!def || !value) {
+        return false;
+    }
+    if (def.code !== value.code) {
+        return false;
+    }
+    for (const argDef of def.args) {
+        const argVal = value.args[argDef.name];
+        if (argDef.required && (argVal == null || argVal === '' || argVal === '0')) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Returns a default value based on the type of the config arg.
+ */
+export function getDefaultConfigArgValue(arg) {
+    return arg.list ? [] : arg.defaultValue ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common/utilities/create-updated-translatable.mjs

@@ -0,0 +1,75 @@
+import { assertNever } from '@vendure/common/lib/shared-utils';
+import { findTranslation } from './find-translation';
+/**
+ * When updating an entity which has translations, the value from the form will pertain to the current
+ * languageCode. This function ensures that the "translations" array is correctly set based on the
+ * existing languages and the updated values in the specified language.
+ */
+export function createUpdatedTranslatable(options) {
+    const { translatable, updatedFields, languageCode, customFieldConfig, defaultTranslation } = options;
+    const currentTranslation = findTranslation(translatable, languageCode) || defaultTranslation || {};
+    const index = translatable.translations.indexOf(currentTranslation);
+    const newTranslation = patchObject(currentTranslation, updatedFields);
+    const newCustomFields = {};
+    const newTranslatedCustomFields = {};
+    if (customFieldConfig && updatedFields.hasOwnProperty('customFields')) {
+        for (const field of customFieldConfig) {
+            const value = updatedFields.customFields[field.name];
+            if (field.type === 'localeString') {
+                newTranslatedCustomFields[field.name] = value;
+            }
+            else {
+                newCustomFields[field.name] =
+                    value === '' ? getDefaultValue(field.type) : value;
+            }
+        }
+        newTranslation.customFields = newTranslatedCustomFields;
+    }
+    const newTranslatable = {
+        ...patchObject(translatable, updatedFields),
+        ...{ translations: translatable.translations.slice() },
+    };
+    if (customFieldConfig) {
+        newTranslatable.customFields = newCustomFields;
+    }
+    if (index !== -1) {
+        newTranslatable.translations.splice(index, 1, newTranslation);
+    }
+    else {
+        newTranslatable.translations.push(newTranslation);
+    }
+    return newTranslatable;
+}
+function getDefaultValue(type) {
+    switch (type) {
+        case 'localeString':
+        case 'string':
+        case 'text':
+            return '';
+        case 'boolean':
+            return false;
+        case 'float':
+        case 'int':
+            return 0;
+        case 'datetime':
+            return new Date();
+        case 'relation':
+            return null;
+        default:
+            assertNever(type);
+    }
+}
+/**
+ * Returns a shallow clone of `obj` with any properties contained in `patch` overwriting
+ * those of `obj`.
+ */
+function patchObject(obj, patch) {
+    const clone = Object.assign({}, obj);
+    Object.keys(clone).forEach(key => {
+        if (patch.hasOwnProperty(key)) {
+            clone[key] = patch[key];
+        }
+    });
+    return clone;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common/utilities/find-translation.mjs

@@ -0,0 +1,9 @@
+/**
+ * @description
+ * Given a translatable entity, returns the translation in the specified LanguageCode if
+ * one exists.
+ */
+export function findTranslation(entity, languageCode) {
+    return (entity?.translations || []).find(t => t.languageCode === languageCode);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC10cmFuc2xhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvY29tbW9uL3V0aWxpdGllcy9maW5kLXRyYW5zbGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUMzQixNQUFxQixFQUNyQixZQUEwQjtJQUUxQixPQUFPLENBQUMsTUFBTSxFQUFFLFlBQVksSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsWUFBWSxLQUFLLFlBQVksQ0FBQyxDQUFDO0FBQ25GLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMYW5ndWFnZUNvZGUgfSBmcm9tICcuLi9nZW5lcmF0ZWQtdHlwZXMnO1xyXG5cclxuZXhwb3J0IHR5cGUgVHJhbnNsYXRpb248VD4gPSBUICYgeyBsYW5ndWFnZUNvZGU6IExhbmd1YWdlQ29kZSB9O1xyXG5leHBvcnQgdHlwZSBQb3NzaWJseVRyYW5zbGF0YWJsZTxUPiA9IHsgdHJhbnNsYXRpb25zPzogQXJyYXk8VHJhbnNsYXRpb248VD4+IHwgbnVsbCB9O1xyXG5leHBvcnQgdHlwZSBUcmFuc2xhdGlvbk9mPEU+ID0gRSBleHRlbmRzIFBvc3NpYmx5VHJhbnNsYXRhYmxlPGluZmVyIFU+ID8gVSA6IHVuZGVmaW5lZDtcclxuXHJcbi8qKlxyXG4gKiBAZGVzY3JpcHRpb25cclxuICogR2l2ZW4gYSB0cmFuc2xhdGFibGUgZW50aXR5LCByZXR1cm5zIHRoZSB0cmFuc2xhdGlvbiBpbiB0aGUgc3BlY2lmaWVkIExhbmd1YWdlQ29kZSBpZlxyXG4gKiBvbmUgZXhpc3RzLlxyXG4gKi9cclxuZXhwb3J0IGZ1bmN0aW9uIGZpbmRUcmFuc2xhdGlvbjxFIGV4dGVuZHMgUG9zc2libHlUcmFuc2xhdGFibGU8YW55Pj4oXHJcbiAgICBlbnRpdHk6IEUgfCB1bmRlZmluZWQsXHJcbiAgICBsYW5ndWFnZUNvZGU6IExhbmd1YWdlQ29kZSxcclxuKTogVHJhbnNsYXRpb25PZjxFPiB8IHVuZGVmaW5lZCB7XHJcbiAgICByZXR1cm4gKGVudGl0eT8udHJhbnNsYXRpb25zIHx8IFtdKS5maW5kKHQgPT4gdC5sYW5ndWFnZUNvZGUgPT09IGxhbmd1YWdlQ29kZSk7XHJcbn1cclxuIl19

package/esm2020/core/common/utilities/flatten-facet-values.mjs

@@ -0,0 +1,4 @@
+export function flattenFacetValues(facetsWithValues) {
+    return facetsWithValues.reduce((flattened, facet) => flattened.concat(facet.values), []);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmxhdHRlbi1mYWNldC12YWx1ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2NvbW1vbi91dGlsaXRpZXMvZmxhdHRlbi1mYWNldC12YWx1ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLGtCQUFrQixDQUFDLGdCQUEyQztJQUMxRSxPQUFPLGdCQUFnQixDQUFDLE1BQU0sQ0FDMUIsQ0FBQyxTQUFTLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxTQUFTLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsRUFDcEQsRUFBMEIsQ0FDN0IsQ0FBQztBQUNOLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGYWNldFZhbHVlRnJhZ21lbnQsIEZhY2V0V2l0aFZhbHVlc0ZyYWdtZW50IH0gZnJvbSAnLi4vZ2VuZXJhdGVkLXR5cGVzJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBmbGF0dGVuRmFjZXRWYWx1ZXMoZmFjZXRzV2l0aFZhbHVlczogRmFjZXRXaXRoVmFsdWVzRnJhZ21lbnRbXSk6IEZhY2V0VmFsdWVGcmFnbWVudFtdIHtcclxuICAgIHJldHVybiBmYWNldHNXaXRoVmFsdWVzLnJlZHVjZShcclxuICAgICAgICAoZmxhdHRlbmVkLCBmYWNldCkgPT4gZmxhdHRlbmVkLmNvbmNhdChmYWNldC52YWx1ZXMpLFxyXG4gICAgICAgIFtdIGFzIEZhY2V0VmFsdWVGcmFnbWVudFtdLFxyXG4gICAgKTtcclxufVxyXG4iXX0=

package/esm2020/core/common/utilities/get-default-ui-language.mjs

@@ -0,0 +1,12 @@
+import { getAppConfig } from '../../app.config';
+export function getDefaultUiLanguage() {
+    return getAppConfig().defaultLanguage;
+}
+export function getDefaultUiLocale() {
+    const defaultLocale = getAppConfig().defaultLocale;
+    if (defaultLocale) {
+        return defaultLocale;
+    }
+    return navigator.language.split('-')[1]?.toUpperCase();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWRlZmF1bHQtdWktbGFuZ3VhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2NvbW1vbi91dGlsaXRpZXMvZ2V0LWRlZmF1bHQtdWktbGFuZ3VhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBR2hELE1BQU0sVUFBVSxvQkFBb0I7SUFDaEMsT0FBTyxZQUFZLEVBQUUsQ0FBQyxlQUFlLENBQUM7QUFDMUMsQ0FBQztBQUVELE1BQU0sVUFBVSxrQkFBa0I7SUFDOUIsTUFBTSxhQUFhLEdBQUcsWUFBWSxFQUFFLENBQUMsYUFBYSxDQUFDO0lBQ25ELElBQUksYUFBYSxFQUFFO1FBQ2YsT0FBTyxhQUFhLENBQUM7S0FDeEI7SUFDRCxPQUFPLFNBQVMsQ0FBQyxRQUFRLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxFQUFFLFdBQVcsRUFBRSxDQUFDO0FBQzNELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXRBcHBDb25maWcgfSBmcm9tICcuLi8uLi9hcHAuY29uZmlnJztcclxuaW1wb3J0IHsgTGFuZ3VhZ2VDb2RlIH0gZnJvbSAnLi4vZ2VuZXJhdGVkLXR5cGVzJztcclxuXHJcbmV4cG9ydCBmdW5jdGlvbiBnZXREZWZhdWx0VWlMYW5ndWFnZSgpOiBMYW5ndWFnZUNvZGUge1xyXG4gICAgcmV0dXJuIGdldEFwcENvbmZpZygpLmRlZmF1bHRMYW5ndWFnZTtcclxufVxyXG5cclxuZXhwb3J0IGZ1bmN0aW9uIGdldERlZmF1bHRVaUxvY2FsZSgpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xyXG4gICAgY29uc3QgZGVmYXVsdExvY2FsZSA9IGdldEFwcENvbmZpZygpLmRlZmF1bHRMb2NhbGU7XHJcbiAgICBpZiAoZGVmYXVsdExvY2FsZSkge1xyXG4gICAgICAgIHJldHVybiBkZWZhdWx0TG9jYWxlO1xyXG4gICAgfVxyXG4gICAgcmV0dXJuIG5hdmlnYXRvci5sYW5ndWFnZS5zcGxpdCgnLScpWzFdPy50b1VwcGVyQ2FzZSgpO1xyXG59XHJcbiJdfQ==

package/{esm2015/core/common/version.js → esm2020/core/common/version.mjs}

@@ -1,3 +1,3 @@
 // Auto-generated by the set-version.js script.
-export const ADMIN_UI_VERSION = '1.4.7';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvY29tbW9uL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEF1dG8tZ2VuZXJhdGVkIGJ5IHRoZSBzZXQtdmVyc2lvbi5qcyBzY3JpcHQuXG5leHBvcnQgY29uc3QgQURNSU5fVUlfVkVSU0lPTiA9ICcxLjQuNyc7XG4iXX0=
+export const ADMIN_UI_VERSION = '2.0.0-next.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvY29tbW9uL3ZlcnNpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFHLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIEF1dG8tZ2VuZXJhdGVkIGJ5IHRoZSBzZXQtdmVyc2lvbi5qcyBzY3JpcHQuXG5leHBvcnQgY29uc3QgQURNSU5fVUlfVkVSU0lPTiA9ICcyLjAuMC1uZXh0LjAnO1xuIl19

package/esm2020/core/components/app-shell/app-shell.component.mjs

@@ -0,0 +1,76 @@
+import { Component } from '@angular/core';
+import { EMPTY } from 'rxjs';
+import { map, switchMap, take } from 'rxjs/operators';
+import { getAppConfig } from '../../app.config';
+import { UiLanguageSwitcherDialogComponent } from '../ui-language-switcher-dialog/ui-language-switcher-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/auth/auth.service";
+import * as i2 from "../../data/providers/data.service";
+import * as i3 from "@angular/router";
+import * as i4 from "../../providers/i18n/i18n.service";
+import * as i5 from "../../providers/modal/modal.service";
+import * as i6 from "../../providers/local-storage/local-storage.service";
+import * as i7 from "@clr/angular";
+import * as i8 from "../channel-switcher/channel-switcher.component";
+import * as i9 from "../user-menu/user-menu.component";
+import * as i10 from "../breadcrumb/breadcrumb.component";
+import * as i11 from "../main-nav/main-nav.component";
+import * as i12 from "../../shared/directives/if-multichannel.directive";
+import * as i13 from "@angular/common";
+export class AppShellComponent {
+    constructor(authService, dataService, router, i18nService, modalService, localStorageService) {
+        this.authService = authService;
+        this.dataService = dataService;
+        this.router = router;
+        this.i18nService = i18nService;
+        this.modalService = modalService;
+        this.localStorageService = localStorageService;
+        this.availableLanguages = [];
+    }
+    ngOnInit() {
+        this.userName$ = this.dataService.client
+            .userStatus()
+            .single$.pipe(map(data => data.userStatus.username));
+        this.uiLanguageAndLocale$ = this.dataService.client
+            .uiState()
+            .stream$.pipe(map(({ uiState }) => [uiState.language, uiState.locale ?? undefined]));
+        this.availableLanguages = this.i18nService.availableLanguages;
+    }
+    selectUiLanguage() {
+        this.uiLanguageAndLocale$
+            .pipe(take(1), switchMap(([currentLanguage, currentLocale]) => this.modalService.fromComponent(UiLanguageSwitcherDialogComponent, {
+            closable: true,
+            size: 'lg',
+            locals: {
+                availableLanguages: this.availableLanguages,
+                currentLanguage,
+                currentLocale,
+            },
+        })), switchMap(result => result ? this.dataService.client.setUiLanguage(result[0], result[1]) : EMPTY))
+            .subscribe(result => {
+            if (result.setUiLanguage) {
+                this.i18nService.setLanguage(result.setUiLanguage);
+                this.localStorageService.set('uiLanguageCode', result.setUiLanguage);
+                this.localStorageService.set('uiLocale', result.setUiLocale ?? undefined);
+            }
+        });
+    }
+    logOut() {
+        this.authService.logOut().subscribe(() => {
+            const { loginUrl } = getAppConfig();
+            if (loginUrl) {
+                window.location.href = loginUrl;
+            }
+            else {
+                this.router.navigate(['/login']);
+            }
+        });
+    }
+}
+AppShellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppShellComponent, deps: [{ token: i1.AuthService }, { token: i2.DataService }, { token: i3.Router }, { token: i4.I18nService }, { token: i5.ModalService }, { token: i6.LocalStorageService }], target: i0.ɵɵFactoryTarget.Component });
+AppShellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: AppShellComponent, selector: "vdr-app-shell", ngImport: i0, template: "<clr-main-container>\r\n    <clr-header>\r\n        <div class=\"branding\">\r\n            <a [routerLink]=\"['/']\"><img src=\"assets/logo-75px.png\" class=\"logo\" /></a>\r\n        </div>\r\n        <div class=\"header-nav\"></div>\r\n        <div class=\"header-actions\">\r\n            <vdr-channel-switcher *vdrIfMultichannel></vdr-channel-switcher>\r\n            <vdr-user-menu [userName]=\"userName$ | async\"\r\n                           [uiLanguageAndLocale]=\"uiLanguageAndLocale$ | async\"\r\n                           [availableLanguages]=\"availableLanguages\"\r\n                           (selectUiLanguage)=\"selectUiLanguage()\"\r\n                           (logOut)=\"logOut()\"></vdr-user-menu>\r\n        </div>\r\n    </clr-header>\r\n    <nav class=\"subnav\"><vdr-breadcrumb></vdr-breadcrumb></nav>\r\n\r\n    <div class=\"content-container\">\r\n        <div class=\"content-area\"><router-outlet></router-outlet></div>\r\n        <vdr-main-nav></vdr-main-nav>\r\n    </div>\r\n</clr-main-container>\r\n", styles: [".branding{min-width:0}.logo{width:60px}@media screen and (min-width: 768px){vdr-breadcrumb{margin-left:10.8rem}}.header-actions{align-items:center}.content-area{position:relative}\n"], components: [{ type: i7.ClrHeader, selector: "clr-header" }, { type: i8.ChannelSwitcherComponent, selector: "vdr-channel-switcher" }, { type: i9.UserMenuComponent, selector: "vdr-user-menu", inputs: ["userName", "availableLanguages", "uiLanguageAndLocale"], outputs: ["logOut", "selectUiLanguage"] }, { type: i10.BreadcrumbComponent, selector: "vdr-breadcrumb" }, { type: i11.MainNavComponent, selector: "vdr-main-nav" }], directives: [{ type: i7.ClrMainContainer, selector: "clr-main-container" }, { type: i7.MainContainerWillyWonka, selector: "clr-main-container" }, { type: i7.NavDetectionOompaLoompa, selector: "clr-header" }, { type: i3.RouterLinkWithHref, selector: "a[routerLink],area[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo", "routerLink"] }, { type: i12.IfMultichannelDirective, selector: "[vdrIfMultichannel]", inputs: ["vdrIfMultichannelElse"] }, { type: i3.RouterOutlet, selector: "router-outlet", outputs: ["activate", "deactivate", "attach", "detach"], exportAs: ["outlet"] }], pipes: { "async": i13.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: AppShellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-app-shell', template: "<clr-main-container>\r\n    <clr-header>\r\n        <div class=\"branding\">\r\n            <a [routerLink]=\"['/']\"><img src=\"assets/logo-75px.png\" class=\"logo\" /></a>\r\n        </div>\r\n        <div class=\"header-nav\"></div>\r\n        <div class=\"header-actions\">\r\n            <vdr-channel-switcher *vdrIfMultichannel></vdr-channel-switcher>\r\n            <vdr-user-menu [userName]=\"userName$ | async\"\r\n                           [uiLanguageAndLocale]=\"uiLanguageAndLocale$ | async\"\r\n                           [availableLanguages]=\"availableLanguages\"\r\n                           (selectUiLanguage)=\"selectUiLanguage()\"\r\n                           (logOut)=\"logOut()\"></vdr-user-menu>\r\n        </div>\r\n    </clr-header>\r\n    <nav class=\"subnav\"><vdr-breadcrumb></vdr-breadcrumb></nav>\r\n\r\n    <div class=\"content-container\">\r\n        <div class=\"content-area\"><router-outlet></router-outlet></div>\r\n        <vdr-main-nav></vdr-main-nav>\r\n    </div>\r\n</clr-main-container>\r\n", styles: [".branding{min-width:0}.logo{width:60px}@media screen and (min-width: 768px){vdr-breadcrumb{margin-left:10.8rem}}.header-actions{align-items:center}.content-area{position:relative}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.AuthService }, { type: i2.DataService }, { type: i3.Router }, { type: i4.I18nService }, { type: i5.ModalService }, { type: i6.LocalStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-shell.component.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/components/app-shell/app-shell.component.ts","../../../../../src/lib/core/src/components/app-shell/app-shell.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\nimport { EMPTY, Observable } from 'rxjs';\r\nimport { map, switchMap, take } from 'rxjs/operators';\r\n\r\nimport { getAppConfig } from '../../app.config';\r\nimport { LanguageCode } from '../../common/generated-types';\r\nimport { DataService } from '../../data/providers/data.service';\r\nimport { AuthService } from '../../providers/auth/auth.service';\r\nimport { I18nService } from '../../providers/i18n/i18n.service';\r\nimport { LocalStorageService } from '../../providers/local-storage/local-storage.service';\r\nimport { ModalService } from '../../providers/modal/modal.service';\r\nimport { UiLanguageSwitcherDialogComponent } from '../ui-language-switcher-dialog/ui-language-switcher-dialog.component';\r\n\r\n@Component({\r\n    selector: 'vdr-app-shell',\r\n    templateUrl: './app-shell.component.html',\r\n    styleUrls: ['./app-shell.component.scss'],\r\n})\r\nexport class AppShellComponent implements OnInit {\r\n    userName$: Observable<string>;\r\n    uiLanguageAndLocale$: Observable<[LanguageCode, string | undefined]>;\r\n    availableLanguages: LanguageCode[] = [];\r\n\r\n    constructor(\r\n        private authService: AuthService,\r\n        private dataService: DataService,\r\n        private router: Router,\r\n        private i18nService: I18nService,\r\n        private modalService: ModalService,\r\n        private localStorageService: LocalStorageService,\r\n    ) {}\r\n\r\n    ngOnInit() {\r\n        this.userName$ = this.dataService.client\r\n            .userStatus()\r\n            .single$.pipe(map(data => data.userStatus.username));\r\n        this.uiLanguageAndLocale$ = this.dataService.client\r\n            .uiState()\r\n            .stream$.pipe(map(({ uiState }) => [uiState.language, uiState.locale ?? undefined]));\r\n        this.availableLanguages = this.i18nService.availableLanguages;\r\n    }\r\n\r\n    selectUiLanguage() {\r\n        this.uiLanguageAndLocale$\r\n            .pipe(\r\n                take(1),\r\n                switchMap(([currentLanguage, currentLocale]) =>\r\n                    this.modalService.fromComponent(UiLanguageSwitcherDialogComponent, {\r\n                        closable: true,\r\n                        size: 'lg',\r\n                        locals: {\r\n                            availableLanguages: this.availableLanguages,\r\n                            currentLanguage,\r\n                            currentLocale,\r\n                        },\r\n                    }),\r\n                ),\r\n                switchMap(result =>\r\n                    result ? this.dataService.client.setUiLanguage(result[0], result[1]) : EMPTY,\r\n                ),\r\n            )\r\n            .subscribe(result => {\r\n                if (result.setUiLanguage) {\r\n                    this.i18nService.setLanguage(result.setUiLanguage);\r\n                    this.localStorageService.set('uiLanguageCode', result.setUiLanguage);\r\n                    this.localStorageService.set('uiLocale', result.setUiLocale ?? undefined);\r\n                }\r\n            });\r\n    }\r\n\r\n    logOut() {\r\n        this.authService.logOut().subscribe(() => {\r\n            const { loginUrl } = getAppConfig();\r\n            if (loginUrl) {\r\n                window.location.href = loginUrl;\r\n            } else {\r\n                this.router.navigate(['/login']);\r\n            }\r\n        });\r\n    }\r\n}\r\n","<clr-main-container>\r\n    <clr-header>\r\n        <div class=\"branding\">\r\n            <a [routerLink]=\"['/']\"><img src=\"assets/logo-75px.png\" class=\"logo\" /></a>\r\n        </div>\r\n        <div class=\"header-nav\"></div>\r\n        <div class=\"header-actions\">\r\n            <vdr-channel-switcher *vdrIfMultichannel></vdr-channel-switcher>\r\n            <vdr-user-menu [userName]=\"userName$ | async\"\r\n                           [uiLanguageAndLocale]=\"uiLanguageAndLocale$ | async\"\r\n                           [availableLanguages]=\"availableLanguages\"\r\n                           (selectUiLanguage)=\"selectUiLanguage()\"\r\n                           (logOut)=\"logOut()\"></vdr-user-menu>\r\n        </div>\r\n    </clr-header>\r\n    <nav class=\"subnav\"><vdr-breadcrumb></vdr-breadcrumb></nav>\r\n\r\n    <div class=\"content-container\">\r\n        <div class=\"content-area\"><router-outlet></router-outlet></div>\r\n        <vdr-main-nav></vdr-main-nav>\r\n    </div>\r\n</clr-main-container>\r\n"]}