@deenruv/admin-ui 1.0.0

package/esm2022/core/common/utilities/bulk-action-utils.mjs

@@ -0,0 +1,271 @@
+import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';
+import { DEFAULT_CHANNEL_CODE } from '@deenruv/common/lib/shared-constants';
+import { EMPTY, from, lastValueFrom, of, switchMap } from 'rxjs';
+import { map, mapTo } from 'rxjs/operators';
+import { DataService } from '../../data/providers/data.service';
+import { ModalService } from '../../providers/modal/modal.service';
+import { NotificationService } from '../../providers/notification/notification.service';
+import { AssignToChannelDialogComponent } from '../../shared/components/assign-to-channel-dialog/assign-to-channel-dialog.component';
+import { DeletionResult } from '../generated-types';
+/**
+ * @description
+ * Resolves to an object containing the Channel code of the given channelId, or if no channelId
+ * is supplied, the code of the activeChannel.
+ */
+export function getChannelCodeFromUserStatus(dataService, channelId) {
+    return lastValueFrom(dataService.client.userStatus().mapSingle(({ userStatus }) => {
+        const channelCode = userStatus.channels.find(c => c.id === (channelId ?? userStatus.activeChannelId))?.code ??
+            'undefined';
+        return { channelCode };
+    }));
+}
+/**
+ * @description
+ * Resolves to `true` if multiple Channels are set up.
+ */
+export function isMultiChannel(dataService) {
+    return lastValueFrom(dataService.client.userStatus().mapSingle(({ userStatus }) => 1 < userStatus.channels.length));
+}
+/**
+ * @description
+ * Resolves to `true` if the current active Channel is not the default Channel.
+ */
+export function currentChannelIsNotDefault(dataService) {
+    return lastValueFrom(dataService.client.userStatus().mapSingle(({ userStatus }) => {
+        if (userStatus.channels.length === 1) {
+            return false;
+        }
+        const defaultChannelId = userStatus.channels.find(c => c.code === DEFAULT_CHANNEL_CODE)?.id;
+        return userStatus.activeChannelId !== defaultChannelId;
+    }));
+}
+/**
+ * @description
+ * Creates a BulkAction which can be used to delete multiple items.
+ */
+export function createBulkDeleteAction(config) {
+    const bulkDeleteAction = {
+        location: config.location,
+        label: _('common.delete'),
+        icon: 'trash',
+        iconClass: 'is-danger',
+        requiresPermission: config.requiresPermission,
+        onClick: ({ injector, selection, hostComponent, clearSelection }) => {
+            const modalService = injector.get(ModalService);
+            const dataService = injector.get(DataService);
+            const notificationService = injector.get(NotificationService);
+            function showModalAndDelete(items, message) {
+                const itemNames = items
+                    .slice(0, 5)
+                    .map(c => config.getItemName(c))
+                    .join(', ');
+                const nMore = items.length > 5 ? items.length - 5 : 0;
+                return modalService
+                    .dialog({
+                    title: _('common.confirm-bulk-delete'),
+                    body: message ? message : nMore ? _('common.list-items-and-n-more') : itemNames,
+                    translationVars: { items: itemNames, nMore },
+                    buttons: [
+                        { type: 'secondary', label: _('common.cancel') },
+                        {
+                            type: 'danger',
+                            label: message ? _('common.force-delete') : _('common.delete'),
+                            returnValue: true,
+                        },
+                    ],
+                })
+                    .pipe(switchMap(res => res
+                    ? config.bulkDelete(dataService, selection.map(c => c.id), message != null)
+                    : of([])));
+            }
+            showModalAndDelete(selection)
+                .pipe(switchMap(result => {
+                let deletedCount = 0;
+                const errors = [];
+                let i = 0;
+                for (const item of result) {
+                    if (item.result === DeletionResult.DELETED) {
+                        deletedCount++;
+                    }
+                    else if (config.shouldRetryItem?.(result[i], selection[i])) {
+                        errors.push({ item: selection[i], message: item.message ?? '' });
+                    }
+                    i++;
+                }
+                if (0 < errors.length) {
+                    return showModalAndDelete(errors.map(e => e.item), errors.map(e => e.message).join('\n')).pipe(map(result2 => {
+                        const deletedCount2 = result2.filter(r => r.result === DeletionResult.DELETED).length;
+                        return deletedCount + deletedCount2;
+                    }));
+                }
+                else {
+                    return of(deletedCount);
+                }
+            }))
+                .subscribe({
+                next: deletedCount => {
+                    if (deletedCount) {
+                        hostComponent.refresh();
+                        clearSelection();
+                        notificationService.success(_('common.notify-delete-success-with-count'), {
+                            count: deletedCount,
+                        });
+                    }
+                    const notDeletedCount = selection.length - deletedCount;
+                    if (0 < notDeletedCount && notDeletedCount < selection.length) {
+                        notificationService.error(_('common.notify-delete-error-with-count'), {
+                            count: notDeletedCount,
+                        });
+                    }
+                    hostComponent.refresh();
+                    clearSelection();
+                },
+                error: err => {
+                    notificationService.error(_('common.notify-delete-error'));
+                },
+            });
+        },
+    };
+    return bulkDeleteAction;
+}
+export function createBulkAssignToChannelAction(config) {
+    const bulkAssignToChannelAction = {
+        location: config.location,
+        label: _('common.assign-to-channel'),
+        icon: 'layers',
+        requiresPermission: config.requiresPermission,
+        onClick: ({ injector, selection, hostComponent, clearSelection }) => {
+            const modalService = injector.get(ModalService);
+            const dataService = injector.get(DataService);
+            const notificationService = injector.get(NotificationService);
+            const itemNames = selection
+                .slice(0, 5)
+                .map(c => config.getItemName(c))
+                .join(', ');
+            const nMore = selection.length > 5 ? selection.length - 5 : 0;
+            modalService
+                .fromComponent(AssignToChannelDialogComponent, {
+                size: 'md',
+                locals: {
+                    itemNames,
+                    nMore,
+                },
+            })
+                .pipe(switchMap(result => {
+                if (result) {
+                    const observables = config.bulkAssignToChannel(dataService, selection.map(c => c.id), result.map(c => c.id));
+                    return from(observables).pipe(switchMap(res => res), mapTo(result));
+                }
+                else {
+                    return EMPTY;
+                }
+            }))
+                .subscribe(result => {
+                notificationService.success(_('common.notify-assign-to-channel-success-with-count'), {
+                    count: selection.length,
+                    channelCode: result.map(c => c.code).join(', '),
+                });
+                clearSelection();
+            });
+        },
+    };
+    return bulkAssignToChannelAction;
+}
+export function createBulkRemoveFromChannelAction(config) {
+    const bulkRemoveFromChannelAction = {
+        location: config.location,
+        label: _('common.remove-from-channel'),
+        icon: 'layers',
+        iconClass: 'is-warning',
+        requiresPermission: config.requiresPermission,
+        onClick: ({ injector, selection, hostComponent, clearSelection }) => {
+            const modalService = injector.get(ModalService);
+            const dataService = injector.get(DataService);
+            const notificationService = injector.get(NotificationService);
+            const activeChannelId$ = dataService.client
+                .userStatus()
+                .mapSingle(({ userStatus }) => userStatus.activeChannelId);
+            function showModalAndDelete(items, message) {
+                const itemNames = items
+                    .slice(0, 5)
+                    .map(c => config.getItemName(c))
+                    .join(', ');
+                const nMore = items.length > 5 ? items.length - 5 : 0;
+                return modalService
+                    .dialog({
+                    title: _('common.confirm-bulk-remove-from-channel'),
+                    body: message ? message : nMore ? _('common.list-items-and-n-more') : itemNames,
+                    translationVars: {
+                        count: selection.length,
+                        items: itemNames,
+                        nMore,
+                    },
+                    size: message ? 'lg' : 'md',
+                    buttons: [
+                        { type: 'secondary', label: _('common.cancel') },
+                        {
+                            type: 'danger',
+                            label: message ? _('common.force-remove') : _('common.remove'),
+                            returnValue: true,
+                        },
+                    ],
+                })
+                    .pipe(switchMap(res => res
+                    ? activeChannelId$.pipe(switchMap(activeChannelId => activeChannelId
+                        ? config.bulkRemoveFromChannel(dataService, selection.map(c => c.id), activeChannelId, message != null)
+                        : EMPTY))
+                    : EMPTY));
+            }
+            showModalAndDelete(selection)
+                .pipe(switchMap(result => {
+                let removedCount = selection.length;
+                const errors = [];
+                const errorIds = [];
+                let i = 0;
+                for (const item of result) {
+                    const errorMessage = config.isErrorResult
+                        ? config.isErrorResult(item)
+                        : undefined;
+                    if (errorMessage) {
+                        errors.push(errorMessage);
+                        errorIds.push(selection[i]?.id);
+                        removedCount--;
+                    }
+                    i++;
+                }
+                if (0 < errorIds.length) {
+                    const errorSelection = selection.filter(s => errorIds.includes(s.id));
+                    return showModalAndDelete(errorSelection, errors.join('\n')).pipe(map(result2 => {
+                        const notRemovedCount = result2.filter(r => {
+                            const secondTryErrorMessage = config.isErrorResult
+                                ? config.isErrorResult(r)
+                                : undefined;
+                            return typeof secondTryErrorMessage === 'string';
+                        }).length;
+                        return selection.length - notRemovedCount;
+                    }));
+                }
+                else {
+                    return of(removedCount);
+                }
+            }), switchMap(removedCount => removedCount
+                ? getChannelCodeFromUserStatus(dataService).then(({ channelCode }) => ({
+                    channelCode,
+                    removedCount,
+                }))
+                : EMPTY))
+                .subscribe(({ removedCount, channelCode }) => {
+                if (removedCount) {
+                    hostComponent.refresh();
+                    clearSelection();
+                    notificationService.success(_('common.notify-remove-from-channel-success-with-count'), {
+                        count: removedCount,
+                        channelCode,
+                    });
+                }
+            });
+        },
+    };
+    return bulkRemoveFromChannelAction;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bulk-action-utils.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/common/utilities/bulk-action-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { marker as _ } from '@biesbjerg/ngx-translate-extract-marker';\nimport { DEFAULT_CHANNEL_CODE } from '@deenruv/common/lib/shared-constants';\nimport { unique } from '@deenruv/common/lib/unique';\nimport { EMPTY, from, lastValueFrom, Observable, of, switchMap } from 'rxjs';\nimport { map, mapTo } from 'rxjs/operators';\n\nimport { DataService } from '../../data/providers/data.service';\nimport { BulkAction } from '../../providers/bulk-action-registry/bulk-action-types';\nimport { ModalService } from '../../providers/modal/modal.service';\nimport { NotificationService } from '../../providers/notification/notification.service';\nimport { AssignToChannelDialogComponent } from '../../shared/components/assign-to-channel-dialog/assign-to-channel-dialog.component';\nimport { BaseListComponent } from '../base-list.component';\nimport { DeletionResponse, DeletionResult } from '../generated-types';\n\n/**\n * @description\n * Resolves to an object containing the Channel code of the given channelId, or if no channelId\n * is supplied, the code of the activeChannel.\n */\nexport function getChannelCodeFromUserStatus(dataService: DataService, channelId?: string) {\n    return lastValueFrom(\n        dataService.client.userStatus().mapSingle(({ userStatus }) => {\n            const channelCode =\n                userStatus.channels.find(c => c.id === (channelId ?? userStatus.activeChannelId))?.code ??\n                'undefined';\n            return { channelCode };\n        }),\n    );\n}\n\n/**\n * @description\n * Resolves to `true` if multiple Channels are set up.\n */\nexport function isMultiChannel(dataService: DataService) {\n    return lastValueFrom(\n        dataService.client.userStatus().mapSingle(({ userStatus }) => 1 < userStatus.channels.length),\n    );\n}\n\n/**\n * @description\n * Resolves to `true` if the current active Channel is not the default Channel.\n */\nexport function currentChannelIsNotDefault(dataService: DataService) {\n    return lastValueFrom(\n        dataService.client.userStatus().mapSingle(({ userStatus }) => {\n            if (userStatus.channels.length === 1) {\n                return false;\n            }\n            const defaultChannelId = userStatus.channels.find(c => c.code === DEFAULT_CHANNEL_CODE)?.id;\n            return userStatus.activeChannelId !== defaultChannelId;\n        }),\n    );\n}\n\nexport type CreateBulkDeleteActionConfig<ItemType> = Pick<BulkAction, 'location' | 'requiresPermission'> & {\n    getItemName: (item: ItemType) => string;\n    shouldRetryItem?: (response: DeletionResponse, item: ItemType) => boolean;\n    bulkDelete: (\n        dataService: DataService,\n        ids: string[],\n        retrying: boolean,\n    ) => Observable<DeletionResponse[]>;\n};\n\n/**\n * @description\n * Creates a BulkAction which can be used to delete multiple items.\n */\nexport function createBulkDeleteAction<ItemType>(config: CreateBulkDeleteActionConfig<ItemType>) {\n    const bulkDeleteAction: BulkAction<any, BaseListComponent<any, any>> = {\n        location: config.location,\n        label: _('common.delete'),\n        icon: 'trash',\n        iconClass: 'is-danger',\n        requiresPermission: config.requiresPermission,\n        onClick: ({ injector, selection, hostComponent, clearSelection }) => {\n            const modalService = injector.get(ModalService);\n            const dataService = injector.get(DataService);\n            const notificationService = injector.get(NotificationService);\n\n            function showModalAndDelete(items: ItemType[], message?: string) {\n                const itemNames = items\n                    .slice(0, 5)\n                    .map(c => config.getItemName(c))\n                    .join(', ');\n                const nMore = items.length > 5 ? items.length - 5 : 0;\n                return modalService\n                    .dialog({\n                        title: _('common.confirm-bulk-delete'),\n                        body: message ? message : nMore ? _('common.list-items-and-n-more') : itemNames,\n                        translationVars: { items: itemNames, nMore },\n                        buttons: [\n                            { type: 'secondary', label: _('common.cancel') },\n                            {\n                                type: 'danger',\n                                label: message ? _('common.force-delete') : _('common.delete'),\n                                returnValue: true,\n                            },\n                        ],\n                    })\n                    .pipe(\n                        switchMap(res =>\n                            res\n                                ? config.bulkDelete(\n                                      dataService,\n                                      selection.map(c => c.id),\n                                      message != null,\n                                  )\n                                : of([]),\n                        ),\n                    );\n            }\n\n            showModalAndDelete(selection)\n                .pipe(\n                    switchMap(result => {\n                        let deletedCount = 0;\n                        const errors: Array<{ item: ItemType; message: string }> = [];\n                        let i = 0;\n                        for (const item of result) {\n                            if (item.result === DeletionResult.DELETED) {\n                                deletedCount++;\n                            } else if (config.shouldRetryItem?.(result[i], selection[i])) {\n                                errors.push({ item: selection[i], message: item.message ?? '' });\n                            }\n                            i++;\n                        }\n                        if (0 < errors.length) {\n                            return showModalAndDelete(\n                                errors.map(e => e.item),\n                                errors.map(e => e.message).join('\\n'),\n                            ).pipe(\n                                map(result2 => {\n                                    const deletedCount2 = result2.filter(\n                                        r => r.result === DeletionResult.DELETED,\n                                    ).length;\n                                    return deletedCount + deletedCount2;\n                                }),\n                            );\n                        } else {\n                            return of(deletedCount);\n                        }\n                    }),\n                )\n                .subscribe({\n                    next: deletedCount => {\n                        if (deletedCount) {\n                            hostComponent.refresh();\n                            clearSelection();\n                            notificationService.success(_('common.notify-delete-success-with-count'), {\n                                count: deletedCount,\n                            });\n                        }\n                        const notDeletedCount = selection.length - deletedCount;\n                        if (0 < notDeletedCount && notDeletedCount < selection.length) {\n                            notificationService.error(_('common.notify-delete-error-with-count'), {\n                                count: notDeletedCount,\n                            });\n                        }\n                        hostComponent.refresh();\n                        clearSelection();\n                    },\n                    error: err => {\n                        notificationService.error(_('common.notify-delete-error'));\n                    },\n                });\n        },\n    };\n    return bulkDeleteAction;\n}\n\nexport type CreateBulkAssignToChannelActionConfig<ItemType> = Pick<\n    BulkAction,\n    'location' | 'requiresPermission'\n> & {\n    getItemName: (item: ItemType) => string;\n    bulkAssignToChannel: (\n        dataService: DataService,\n        ids: string[],\n        channelIds: string[],\n    ) => Array<Observable<Array<Partial<ItemType>>>>;\n};\n\nexport function createBulkAssignToChannelAction<ItemType>(\n    config: CreateBulkAssignToChannelActionConfig<ItemType>,\n) {\n    const bulkAssignToChannelAction: BulkAction<any, BaseListComponent<any, any>> = {\n        location: config.location,\n        label: _('common.assign-to-channel'),\n        icon: 'layers',\n        requiresPermission: config.requiresPermission,\n        onClick: ({ injector, selection, hostComponent, clearSelection }) => {\n            const modalService = injector.get(ModalService);\n            const dataService = injector.get(DataService);\n            const notificationService = injector.get(NotificationService);\n            const itemNames = selection\n                .slice(0, 5)\n                .map(c => config.getItemName(c))\n                .join(', ');\n            const nMore = selection.length > 5 ? selection.length - 5 : 0;\n            modalService\n                .fromComponent(AssignToChannelDialogComponent, {\n                    size: 'md',\n                    locals: {\n                        itemNames,\n                        nMore,\n                    },\n                })\n                .pipe(\n                    switchMap(result => {\n                        if (result) {\n                            const observables = config.bulkAssignToChannel(\n                                dataService,\n                                selection.map(c => c.id),\n                                result.map(c => c.id),\n                            );\n\n                            return from(observables).pipe(\n                                switchMap(res => res),\n                                mapTo(result),\n                            );\n                        } else {\n                            return EMPTY;\n                        }\n                    }),\n                )\n                .subscribe(result => {\n                    notificationService.success(_('common.notify-assign-to-channel-success-with-count'), {\n                        count: selection.length,\n                        channelCode: result.map(c => c.code).join(', '),\n                    });\n                    clearSelection();\n                });\n        },\n    };\n    return bulkAssignToChannelAction;\n}\n\nexport type CreateBulkRemoveFromChannelActionConfig<ItemType, RemoveResult = Partial<ItemType>> = Pick<\n    BulkAction,\n    'location' | 'requiresPermission'\n> & {\n    getItemName: (item: ItemType) => string;\n    bulkRemoveFromChannel: (\n        dataService: DataService,\n        ids: string[],\n        channelId: string,\n        retrying: boolean,\n    ) => Observable<RemoveResult[]>;\n    /**\n     * An optional test of whether the removal succeeded for the given item. If this\n     * function returns a string, that is taken to be an error message which will be\n     * displayed to the user.\n     */\n    isErrorResult?: (result: RemoveResult) => string | undefined;\n};\n\nexport function createBulkRemoveFromChannelAction<ItemType, ResultType = Partial<ItemType>>(\n    config: CreateBulkRemoveFromChannelActionConfig<ItemType, ResultType>,\n) {\n    const bulkRemoveFromChannelAction: BulkAction<any, BaseListComponent<any, any>> = {\n        location: config.location,\n        label: _('common.remove-from-channel'),\n        icon: 'layers',\n        iconClass: 'is-warning',\n        requiresPermission: config.requiresPermission,\n        onClick: ({ injector, selection, hostComponent, clearSelection }) => {\n            const modalService = injector.get(ModalService);\n            const dataService = injector.get(DataService);\n            const notificationService = injector.get(NotificationService);\n            const activeChannelId$ = dataService.client\n                .userStatus()\n                .mapSingle(({ userStatus }) => userStatus.activeChannelId);\n\n            function showModalAndDelete(items: ItemType[], message?: string) {\n                const itemNames = items\n                    .slice(0, 5)\n                    .map(c => config.getItemName(c))\n                    .join(', ');\n                const nMore = items.length > 5 ? items.length - 5 : 0;\n                return modalService\n                    .dialog({\n                        title: _('common.confirm-bulk-remove-from-channel'),\n                        body: message ? message : nMore ? _('common.list-items-and-n-more') : itemNames,\n                        translationVars: {\n                            count: selection.length,\n                            items: itemNames,\n                            nMore,\n                        },\n                        size: message ? 'lg' : 'md',\n                        buttons: [\n                            { type: 'secondary', label: _('common.cancel') },\n                            {\n                                type: 'danger',\n                                label: message ? _('common.force-remove') : _('common.remove'),\n                                returnValue: true,\n                            },\n                        ],\n                    })\n                    .pipe(\n                        switchMap(res =>\n                            res\n                                ? activeChannelId$.pipe(\n                                      switchMap(activeChannelId =>\n                                          activeChannelId\n                                              ? config.bulkRemoveFromChannel(\n                                                    dataService,\n                                                    selection.map(c => c.id),\n                                                    activeChannelId,\n                                                    message != null,\n                                                )\n                                              : EMPTY,\n                                      ),\n                                  )\n                                : EMPTY,\n                        ),\n                    );\n            }\n\n            showModalAndDelete(selection)\n                .pipe(\n                    switchMap(result => {\n                        let removedCount = selection.length;\n                        const errors: string[] = [];\n                        const errorIds: string[] = [];\n                        let i = 0;\n                        for (const item of result) {\n                            const errorMessage = config.isErrorResult\n                                ? config.isErrorResult(item)\n                                : undefined;\n                            if (errorMessage) {\n                                errors.push(errorMessage);\n                                errorIds.push(selection[i]?.id);\n                                removedCount--;\n                            }\n                            i++;\n                        }\n                        if (0 < errorIds.length) {\n                            const errorSelection = selection.filter(s => errorIds.includes(s.id));\n                            return showModalAndDelete(errorSelection, errors.join('\\n')).pipe(\n                                map(result2 => {\n                                    const notRemovedCount = result2.filter(r => {\n                                        const secondTryErrorMessage = config.isErrorResult\n                                            ? config.isErrorResult(r)\n                                            : undefined;\n                                        return typeof secondTryErrorMessage === 'string';\n                                    }).length;\n                                    return selection.length - notRemovedCount;\n                                }),\n                            );\n                        } else {\n                            return of(removedCount);\n                        }\n                    }),\n                    switchMap(removedCount =>\n                        removedCount\n                            ? getChannelCodeFromUserStatus(dataService).then(({ channelCode }) => ({\n                                  channelCode,\n                                  removedCount,\n                              }))\n                            : EMPTY,\n                    ),\n                )\n                .subscribe(({ removedCount, channelCode }) => {\n                    if (removedCount) {\n                        hostComponent.refresh();\n                        clearSelection();\n                        notificationService.success(\n                            _('common.notify-remove-from-channel-success-with-count'),\n                            {\n                                count: removedCount,\n                                channelCode,\n                            },\n                        );\n                    }\n                });\n        },\n    };\n    return bulkRemoveFromChannelAction;\n}\n"]}

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

@@ -0,0 +1,116 @@
+import { assertNever } from '@deenruv/common/lib/shared-utils';
+/**
+ * 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 {
+        const result = value != null ? JSON.parse(value) : undefined;
+        if (result && typeof result === 'object' && !Array.isArray(result)) {
+            // There is an edge-case where the value is a valid JSON-encoded string and
+            // will get parsed as an object, but we actually want it to be a string.
+            return JSON.stringify(result);
+        }
+        else {
+            return result;
+        }
+    }
+    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 => ({
+            ...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',
+ *     arguments: [
+ *         { name: 'someProperty', value: 'foo' }
+ *     ]
+ * }
+ * ```
+ */
+export function toConfigurableOperationInput(operation, formValueOperations) {
+    const argsArray = Array.isArray(formValueOperations.args) ? formValueOperations.args : undefined;
+    const argsMap = !Array.isArray(formValueOperations.args) ? formValueOperations.args : undefined;
+    return {
+        code: operation.code,
+        arguments: operation.args.map(({ name, value }, j) => {
+            const formValue = argsArray?.find(arg => arg.name === name)?.value ?? argsMap?.[name];
+            if (formValue == null) {
+                throw new Error(`Cannot find an argument value for the key "${name}"`);
+            }
+            return {
+                name,
+                value: formValue?.hasOwnProperty('value')
+                    ? encodeConfigArgValue(formValue.value)
+                    : encodeConfigArgValue(formValue),
+            };
+        }),
+    };
+}
+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) {
+    if (arg.list) {
+        return [];
+    }
+    if (arg.defaultValue != null) {
+        return arg.defaultValue;
+    }
+    const type = arg.type;
+    switch (type) {
+        case 'string':
+        case 'datetime':
+        case 'float':
+        case 'ID':
+        case 'int':
+            return null;
+        case 'boolean':
+            return false;
+        default:
+            assertNever(type);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configurable-operation-utils.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/common/utilities/configurable-operation-utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { ConfigArgType } from '@deenruv/common/lib/shared-types';\nimport { assertNever } from '@deenruv/common/lib/shared-utils';\n\nimport {\n    ConfigArgDefinition,\n    ConfigurableOperation,\n    ConfigurableOperationDefinition,\n    ConfigurableOperationInput,\n} from '../generated-types';\n\n/**\n * ConfigArg values are always stored as strings. If they are not primitives, then\n * they are JSON-encoded. This function unwraps them back into their original\n * data type.\n */\nexport function getConfigArgValue(value: any) {\n    try {\n        const result = value != null ? JSON.parse(value) : undefined;\n        if (result && typeof result === 'object' && !Array.isArray(result)) {\n            // There is an edge-case where the value is a valid JSON-encoded string and\n            // will get parsed as an object, but we actually want it to be a string.\n            return JSON.stringify(result);\n        } else {\n            return result;\n        }\n    } catch (e: any) {\n        return value;\n    }\n}\n\nexport function encodeConfigArgValue(value: any): string {\n    return Array.isArray(value) ? JSON.stringify(value) : (value ?? '').toString();\n}\n\n/**\n * Creates an empty ConfigurableOperation object based on the definition.\n */\nexport function configurableDefinitionToInstance(\n    def: Omit<ConfigurableOperationDefinition, '__typename'>,\n): ConfigurableOperation {\n    return {\n        ...def,\n        args: def.args.map(arg => ({\n            ...arg,\n            value: getDefaultConfigArgValue(arg),\n        })),\n    } as ConfigurableOperation;\n}\n\n/**\n * Converts an object of the type:\n * ```\n * {\n *     code: 'my-operation',\n *     args: {\n *         someProperty: 'foo'\n *     }\n * }\n * ```\n * to the format defined by the ConfigurableOperationInput GraphQL input type:\n * ```\n * {\n *     code: 'my-operation',\n *     arguments: [\n *         { name: 'someProperty', value: 'foo' }\n *     ]\n * }\n * ```\n */\nexport function toConfigurableOperationInput(\n    operation: Omit<ConfigurableOperation, '__typename'>,\n    formValueOperations: { args: Record<string, string> | Array<{ name: string; value: string }> },\n): ConfigurableOperationInput {\n    const argsArray = Array.isArray(formValueOperations.args) ? formValueOperations.args : undefined;\n    const argsMap = !Array.isArray(formValueOperations.args) ? formValueOperations.args : undefined;\n    return {\n        code: operation.code,\n        arguments: operation.args.map(({ name, value }, j) => {\n            const formValue = argsArray?.find(arg => arg.name === name)?.value ?? argsMap?.[name];\n            if (formValue == null) {\n                throw new Error(`Cannot find an argument value for the key \"${name}\"`);\n            }\n            return {\n                name,\n                value: formValue?.hasOwnProperty('value')\n                    ? encodeConfigArgValue((formValue as any).value)\n                    : encodeConfigArgValue(formValue),\n            };\n        }),\n    };\n}\n\nexport function configurableOperationValueIsValid(\n    def?: ConfigurableOperationDefinition,\n    value?: { code: string; args: { [key: string]: string } },\n) {\n    if (!def || !value) {\n        return false;\n    }\n    if (def.code !== value.code) {\n        return false;\n    }\n    for (const argDef of def.args) {\n        const argVal = value.args[argDef.name];\n        if (argDef.required && (argVal == null || argVal === '' || argVal === '0')) {\n            return false;\n        }\n    }\n    return true;\n}\n\n/**\n * Returns a default value based on the type of the config arg.\n */\nexport function getDefaultConfigArgValue(arg: ConfigArgDefinition): any {\n    if (arg.list) {\n        return [];\n    }\n    if (arg.defaultValue != null) {\n        return arg.defaultValue;\n    }\n    const type = arg.type as ConfigArgType;\n    switch (type) {\n        case 'string':\n        case 'datetime':\n        case 'float':\n        case 'ID':\n        case 'int':\n            return null;\n        case 'boolean':\n            return false;\n        default:\n            assertNever(type);\n    }\n}\n"]}

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

@@ -0,0 +1,58 @@
+import { findTranslation } from './find-translation';
+import { getDefaultValue } from './custom-field-default-value';
+/**
+ * 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' || field.type === 'localeText') {
+                newTranslatedCustomFields[field.name] = value;
+            }
+            else {
+                newCustomFields[field.name] =
+                    value === ''
+                        ? getDefaultValue(field.type, field.nullable ?? true)
+                        : 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;
+}
+/**
+ * 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/esm2022/core/common/utilities/custom-field-default-value.mjs

@@ -0,0 +1,28 @@
+import { assertNever } from '@deenruv/common/lib/shared-utils';
+export function getCustomFieldsDefaults(customFieldConfig) {
+    return customFieldConfig.reduce((hash, field) => ({
+        ...hash,
+        [field.name]: getDefaultValue(field.type, field.nullable ?? undefined),
+    }), {});
+}
+export function getDefaultValue(type, isNullable) {
+    switch (type) {
+        case 'localeString':
+        case 'string':
+        case 'text':
+        case 'localeText':
+            return isNullable ? null : '';
+        case 'boolean':
+            return isNullable ? null : false;
+        case 'float':
+        case 'int':
+            return isNullable ? null : 0;
+        case 'datetime':
+            return isNullable ? null : new Date();
+        case 'relation':
+            return null;
+        default:
+            assertNever(type);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmluZC10cmFuc2xhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvY29tbW9uL3V0aWxpdGllcy9maW5kLXRyYW5zbGF0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQU1BOzs7O0dBSUc7QUFDSCxNQUFNLFVBQVUsZUFBZSxDQUMzQixNQUFxQixFQUNyQixZQUEwQjtJQUUxQixPQUFPLENBQUMsTUFBTSxFQUFFLFlBQVksSUFBSSxFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsWUFBWSxLQUFLLFlBQVksQ0FBQyxDQUFDO0FBQ25GLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBMYW5ndWFnZUNvZGUgfSBmcm9tICcuLi9nZW5lcmF0ZWQtdHlwZXMnO1xuXG5leHBvcnQgdHlwZSBUcmFuc2xhdGlvbjxUPiA9IFQgJiB7IGxhbmd1YWdlQ29kZTogTGFuZ3VhZ2VDb2RlIH07XG5leHBvcnQgdHlwZSBQb3NzaWJseVRyYW5zbGF0YWJsZTxUPiA9IHsgdHJhbnNsYXRpb25zPzogQXJyYXk8VHJhbnNsYXRpb248VD4+IHwgbnVsbCB9O1xuZXhwb3J0IHR5cGUgVHJhbnNsYXRpb25PZjxFPiA9IEUgZXh0ZW5kcyBQb3NzaWJseVRyYW5zbGF0YWJsZTxpbmZlciBVPiA/IFUgOiB1bmRlZmluZWQ7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uXG4gKiBHaXZlbiBhIHRyYW5zbGF0YWJsZSBlbnRpdHksIHJldHVybnMgdGhlIHRyYW5zbGF0aW9uIGluIHRoZSBzcGVjaWZpZWQgTGFuZ3VhZ2VDb2RlIGlmXG4gKiBvbmUgZXhpc3RzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZmluZFRyYW5zbGF0aW9uPEUgZXh0ZW5kcyBQb3NzaWJseVRyYW5zbGF0YWJsZTxhbnk+PihcbiAgICBlbnRpdHk6IEUgfCB1bmRlZmluZWQsXG4gICAgbGFuZ3VhZ2VDb2RlOiBMYW5ndWFnZUNvZGUsXG4pOiBUcmFuc2xhdGlvbk9mPEU+IHwgdW5kZWZpbmVkIHtcbiAgICByZXR1cm4gKGVudGl0eT8udHJhbnNsYXRpb25zIHx8IFtdKS5maW5kKHQgPT4gdC5sYW5ndWFnZUNvZGUgPT09IGxhbmd1YWdlQ29kZSk7XG59XG4iXX0=

package/esm2022/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWRlZmF1bHQtdWktbGFuZ3VhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL2NvbW1vbi91dGlsaXRpZXMvZ2V0LWRlZmF1bHQtdWktbGFuZ3VhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBR2hELE1BQU0sVUFBVSxvQkFBb0I7SUFDaEMsT0FBTyxZQUFZLEVBQUUsQ0FBQyxlQUFlLENBQUM7QUFDMUMsQ0FBQztBQUVELE1BQU0sVUFBVSxrQkFBa0I7SUFDOUIsTUFBTSxhQUFhLEdBQUcsWUFBWSxFQUFFLENBQUMsYUFBYSxDQUFDO0lBQ25ELElBQUksYUFBYSxFQUFFLENBQUM7UUFDaEIsT0FBTyxhQUFhLENBQUM7SUFDekIsQ0FBQztJQUNELE9BQU8sU0FBUyxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsV0FBVyxFQUFFLENBQUM7QUFDM0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldEFwcENvbmZpZyB9IGZyb20gJy4uLy4uL2FwcC5jb25maWcnO1xuaW1wb3J0IHsgTGFuZ3VhZ2VDb2RlIH0gZnJvbSAnLi4vZ2VuZXJhdGVkLXR5cGVzJztcblxuZXhwb3J0IGZ1bmN0aW9uIGdldERlZmF1bHRVaUxhbmd1YWdlKCk6IExhbmd1YWdlQ29kZSB7XG4gICAgcmV0dXJuIGdldEFwcENvbmZpZygpLmRlZmF1bHRMYW5ndWFnZTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldERlZmF1bHRVaUxvY2FsZSgpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICAgIGNvbnN0IGRlZmF1bHRMb2NhbGUgPSBnZXRBcHBDb25maWcoKS5kZWZhdWx0TG9jYWxlO1xuICAgIGlmIChkZWZhdWx0TG9jYWxlKSB7XG4gICAgICAgIHJldHVybiBkZWZhdWx0TG9jYWxlO1xuICAgIH1cbiAgICByZXR1cm4gbmF2aWdhdG9yLmxhbmd1YWdlLnNwbGl0KCctJylbMV0/LnRvVXBwZXJDYXNlKCk7XG59XG4iXX0=