@deenruv/admin-ui 1.0.0

package/esm2022/core/data/utils/add-custom-fields.mjs

@@ -0,0 +1,84 @@
+import { Kind, } from 'graphql';
+/**
+ * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured
+ * custom fields to those fragments.
+ */
+export function addCustomFields(documentNode, customFields) {
+    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);
+    for (const fragmentDef of fragmentDefs) {
+        let entityType = fragmentDef.typeCondition.name.value;
+        if (entityType === 'OrderAddress') {
+            // OrderAddress is a special case of the Address entity, and shares its custom fields
+            // so we treat it as an alias
+            entityType = 'Address';
+        }
+        if (entityType === 'Country') {
+            // Country is an alias of Region
+            entityType = 'Region';
+        }
+        const customFieldsForType = customFields.get(entityType);
+        if (customFieldsForType && customFieldsForType.length) {
+            fragmentDef.selectionSet.selections.push({
+                name: {
+                    kind: Kind.NAME,
+                    value: 'customFields',
+                },
+                kind: Kind.FIELD,
+                selectionSet: {
+                    kind: Kind.SELECTION_SET,
+                    selections: customFieldsForType.map(customField => ({
+                        kind: Kind.FIELD,
+                        name: {
+                            kind: Kind.NAME,
+                            value: customField.name,
+                        },
+                        // For "relation" custom fields, we need to also select
+                        // all the scalar fields of the related type
+                        ...(customField.type === 'relation'
+                            ? {
+                                selectionSet: {
+                                    kind: Kind.SELECTION_SET,
+                                    selections: customField.scalarFields.map(f => ({
+                                        kind: Kind.FIELD,
+                                        name: { kind: Kind.NAME, value: f },
+                                    })),
+                                },
+                            }
+                            : {}),
+                    })),
+                },
+            });
+            const localizedFields = customFieldsForType.filter(field => field.type === 'localeString' || field.type === 'localeText');
+            const translationsField = fragmentDef.selectionSet.selections
+                .filter(isFieldNode)
+                .find(field => field.name.value === 'translations');
+            if (localizedFields.length && translationsField && translationsField.selectionSet) {
+                translationsField.selectionSet.selections.push({
+                    name: {
+                        kind: Kind.NAME,
+                        value: 'customFields',
+                    },
+                    kind: Kind.FIELD,
+                    selectionSet: {
+                        kind: Kind.SELECTION_SET,
+                        selections: localizedFields.map(customField => ({
+                            kind: Kind.FIELD,
+                            name: {
+                                kind: Kind.NAME,
+                                value: customField.name,
+                            },
+                        })),
+                    },
+                });
+            }
+        }
+    }
+    return documentNode;
+}
+function isFragmentDefinition(value) {
+    return value.kind === Kind.FRAGMENT_DEFINITION;
+}
+function isFieldNode(value) {
+    return value.kind === Kind.FIELD;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"add-custom-fields.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/utils/add-custom-fields.ts"],"names":[],"mappings":"AAAA,OAAO,EAKH,IAAI,GAEP,MAAM,SAAS,CAAC;AASjB;;;GAGG;AACH,MAAM,UAAU,eAAe,CAC3B,YAA0B,EAC1B,YAA8C;IAE9C,MAAM,YAAY,GAAG,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;IAE3E,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACrC,IAAI,UAAU,GAAG,WAAW,CAAC,aAAa,CAAC,IAAI,CAAC,KAG/C,CAAC;QAEF,IAAI,UAAU,KAAM,cAAsB,EAAE,CAAC;YACzC,qFAAqF;YACrF,6BAA6B;YAC7B,UAAU,GAAG,SAAS,CAAC;QAC3B,CAAC;QAED,IAAI,UAAU,KAAM,SAAiB,EAAE,CAAC;YACpC,gCAAgC;YAChC,UAAU,GAAG,QAAQ,CAAC;QAC1B,CAAC;QAED,MAAM,mBAAmB,GAAG,YAAY,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;QACzD,IAAI,mBAAmB,IAAI,mBAAmB,CAAC,MAAM,EAAE,CAAC;YACnD,WAAW,CAAC,YAAY,CAAC,UAA8B,CAAC,IAAI,CAAC;gBAC1D,IAAI,EAAE;oBACF,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,KAAK,EAAE,cAAc;iBACxB;gBACD,IAAI,EAAE,IAAI,CAAC,KAAK;gBAChB,YAAY,EAAE;oBACV,IAAI,EAAE,IAAI,CAAC,aAAa;oBACxB,UAAU,EAAE,mBAAmB,CAAC,GAAG,CAC/B,WAAW,CAAC,EAAE,CACV,CAAC;wBACG,IAAI,EAAE,IAAI,CAAC,KAAK;wBAChB,IAAI,EAAE;4BACF,IAAI,EAAE,IAAI,CAAC,IAAI;4BACf,KAAK,EAAE,WAAW,CAAC,IAAI;yBAC1B;wBACD,uDAAuD;wBACvD,4CAA4C;wBAC5C,GAAG,CAAC,WAAW,CAAC,IAAI,KAAK,UAAU;4BAC/B,CAAC,CAAC;gCACI,YAAY,EAAE;oCACV,IAAI,EAAE,IAAI,CAAC,aAAa;oCACxB,UAAU,EACN,WACH,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;wCACrB,IAAI,EAAE,IAAI,CAAC,KAAK;wCAChB,IAAI,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE;qCACtC,CAAC,CAAC;iCACN;6BACJ;4BACH,CAAC,CAAC,EAAE,CAAC;qBACE,CAAA,CACtB;iBACJ;aACJ,CAAC,CAAC;YAEH,MAAM,eAAe,GAAG,mBAAmB,CAAC,MAAM,CAC9C,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,cAAc,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,CACxE,CAAC;YAEF,MAAM,iBAAiB,GAAG,WAAW,CAAC,YAAY,CAAC,UAAU;iBACxD,MAAM,CAAC,WAAW,CAAC;iBACnB,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,KAAK,cAAc,CAAC,CAAC;YAExD,IAAI,eAAe,CAAC,MAAM,IAAI,iBAAiB,IAAI,iBAAiB,CAAC,YAAY,EAAE,CAAC;gBAC/E,iBAAiB,CAAC,YAAY,CAAC,UAA8B,CAAC,IAAI,CAAC;oBAChE,IAAI,EAAE;wBACF,IAAI,EAAE,IAAI,CAAC,IAAI;wBACf,KAAK,EAAE,cAAc;qBACxB;oBACD,IAAI,EAAE,IAAI,CAAC,KAAK;oBAChB,YAAY,EAAE;wBACV,IAAI,EAAE,IAAI,CAAC,aAAa;wBACxB,UAAU,EAAE,eAAe,CAAC,GAAG,CAC3B,WAAW,CAAC,EAAE,CACV,CAAC;4BACG,IAAI,EAAE,IAAI,CAAC,KAAK;4BAChB,IAAI,EAAE;gCACF,IAAI,EAAE,IAAI,CAAC,IAAI;gCACf,KAAK,EAAE,WAAW,CAAC,IAAI;6BAC1B;yBACU,CAAA,CACtB;qBACJ;iBACJ,CAAC,CAAC;YACP,CAAC;QACL,CAAC;IACL,CAAC;IAED,OAAO,YAAY,CAAC;AACxB,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAqB;IAC/C,OAAO,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,mBAAmB,CAAC;AACnD,CAAC;AAED,SAAS,WAAW,CAAC,KAAoB;IACrC,OAAO,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,KAAK,CAAC;AACrC,CAAC","sourcesContent":["import {\n    DefinitionNode,\n    DocumentNode,\n    FieldNode,\n    FragmentDefinitionNode,\n    Kind,\n    SelectionNode,\n} from 'graphql';\n\nimport {\n    CustomFieldConfig,\n    CustomFields,\n    EntityCustomFields,\n    RelationCustomFieldFragment,\n} from '../../common/generated-types';\n\n/**\n * Given a GraphQL AST (DocumentNode), this function looks for fragment definitions and adds and configured\n * custom fields to those fragments.\n */\nexport function addCustomFields(\n    documentNode: DocumentNode,\n    customFields: Map<string, CustomFieldConfig[]>,\n): DocumentNode {\n    const fragmentDefs = documentNode.definitions.filter(isFragmentDefinition);\n\n    for (const fragmentDef of fragmentDefs) {\n        let entityType = fragmentDef.typeCondition.name.value as keyof Pick<\n            CustomFields,\n            Exclude<keyof CustomFields, '__typename'>\n        >;\n\n        if (entityType === ('OrderAddress' as any)) {\n            // OrderAddress is a special case of the Address entity, and shares its custom fields\n            // so we treat it as an alias\n            entityType = 'Address';\n        }\n\n        if (entityType === ('Country' as any)) {\n            // Country is an alias of Region\n            entityType = 'Region';\n        }\n\n        const customFieldsForType = customFields.get(entityType);\n        if (customFieldsForType && customFieldsForType.length) {\n            (fragmentDef.selectionSet.selections as SelectionNode[]).push({\n                name: {\n                    kind: Kind.NAME,\n                    value: 'customFields',\n                },\n                kind: Kind.FIELD,\n                selectionSet: {\n                    kind: Kind.SELECTION_SET,\n                    selections: customFieldsForType.map(\n                        customField =>\n                            ({\n                                kind: Kind.FIELD,\n                                name: {\n                                    kind: Kind.NAME,\n                                    value: customField.name,\n                                },\n                                // For \"relation\" custom fields, we need to also select\n                                // all the scalar fields of the related type\n                                ...(customField.type === 'relation'\n                                    ? {\n                                          selectionSet: {\n                                              kind: Kind.SELECTION_SET,\n                                              selections: (\n                                                  customField as RelationCustomFieldFragment\n                                              ).scalarFields.map(f => ({\n                                                  kind: Kind.FIELD,\n                                                  name: { kind: Kind.NAME, value: f },\n                                              })),\n                                          },\n                                      }\n                                    : {}),\n                            } as FieldNode),\n                    ),\n                },\n            });\n\n            const localizedFields = customFieldsForType.filter(\n                field => field.type === 'localeString' || field.type === 'localeText',\n            );\n\n            const translationsField = fragmentDef.selectionSet.selections\n                .filter(isFieldNode)\n                .find(field => field.name.value === 'translations');\n\n            if (localizedFields.length && translationsField && translationsField.selectionSet) {\n                (translationsField.selectionSet.selections as SelectionNode[]).push({\n                    name: {\n                        kind: Kind.NAME,\n                        value: 'customFields',\n                    },\n                    kind: Kind.FIELD,\n                    selectionSet: {\n                        kind: Kind.SELECTION_SET,\n                        selections: localizedFields.map(\n                            customField =>\n                                ({\n                                    kind: Kind.FIELD,\n                                    name: {\n                                        kind: Kind.NAME,\n                                        value: customField.name,\n                                    },\n                                } as FieldNode),\n                        ),\n                    },\n                });\n            }\n        }\n    }\n\n    return documentNode;\n}\n\nfunction isFragmentDefinition(value: DefinitionNode): value is FragmentDefinitionNode {\n    return value.kind === Kind.FRAGMENT_DEFINITION;\n}\n\nfunction isFieldNode(value: SelectionNode): value is FieldNode {\n    return value.kind === Kind.FIELD;\n}\n"]}

package/esm2022/core/data/utils/get-server-location.mjs

@@ -0,0 +1,17 @@
+import { getAppConfig } from '../../app.config';
+/**
+ * Returns the location of the server, e.g. "http://localhost:3000"
+ */
+export function getServerLocation() {
+    const { apiHost, apiPort, adminApiPath, tokenMethod } = getAppConfig();
+    const host = apiHost === 'auto' ? `${location.protocol}//${location.hostname}` : apiHost;
+    const port = apiPort
+        ? apiPort === 'auto'
+            ? location.port === ''
+                ? ''
+                : `:${location.port}`
+            : `:${apiPort}`
+        : '';
+    return `${host}${port}`;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXNlcnZlci1sb2NhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saWIvY29yZS9zcmMvZGF0YS91dGlscy9nZXQtc2VydmVyLWxvY2F0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVoRDs7R0FFRztBQUNILE1BQU0sVUFBVSxpQkFBaUI7SUFDN0IsTUFBTSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsWUFBWSxFQUFFLFdBQVcsRUFBRSxHQUFHLFlBQVksRUFBRSxDQUFDO0lBQ3ZFLE1BQU0sSUFBSSxHQUFHLE9BQU8sS0FBSyxNQUFNLENBQUMsQ0FBQyxDQUFDLEdBQUcsUUFBUSxDQUFDLFFBQVEsS0FBSyxRQUFRLENBQUMsUUFBUSxFQUFFLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQztJQUN6RixNQUFNLElBQUksR0FBRyxPQUFPO1FBQ2hCLENBQUMsQ0FBQyxPQUFPLEtBQUssTUFBTTtZQUNoQixDQUFDLENBQUMsUUFBUSxDQUFDLElBQUksS0FBSyxFQUFFO2dCQUNsQixDQUFDLENBQUMsRUFBRTtnQkFDSixDQUFDLENBQUMsSUFBSSxRQUFRLENBQUMsSUFBSSxFQUFFO1lBQ3pCLENBQUMsQ0FBQyxJQUFJLE9BQU8sRUFBRTtRQUNuQixDQUFDLENBQUMsRUFBRSxDQUFDO0lBQ1QsT0FBTyxHQUFHLElBQUksR0FBRyxJQUFJLEVBQUUsQ0FBQztBQUM1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0QXBwQ29uZmlnIH0gZnJvbSAnLi4vLi4vYXBwLmNvbmZpZyc7XG5cbi8qKlxuICogUmV0dXJucyB0aGUgbG9jYXRpb24gb2YgdGhlIHNlcnZlciwgZS5nLiBcImh0dHA6Ly9sb2NhbGhvc3Q6MzAwMFwiXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBnZXRTZXJ2ZXJMb2NhdGlvbigpOiBzdHJpbmcge1xuICAgIGNvbnN0IHsgYXBpSG9zdCwgYXBpUG9ydCwgYWRtaW5BcGlQYXRoLCB0b2tlbk1ldGhvZCB9ID0gZ2V0QXBwQ29uZmlnKCk7XG4gICAgY29uc3QgaG9zdCA9IGFwaUhvc3QgPT09ICdhdXRvJyA/IGAke2xvY2F0aW9uLnByb3RvY29sfS8vJHtsb2NhdGlvbi5ob3N0bmFtZX1gIDogYXBpSG9zdDtcbiAgICBjb25zdCBwb3J0ID0gYXBpUG9ydFxuICAgICAgICA/IGFwaVBvcnQgPT09ICdhdXRvJ1xuICAgICAgICAgICAgPyBsb2NhdGlvbi5wb3J0ID09PSAnJ1xuICAgICAgICAgICAgICAgID8gJydcbiAgICAgICAgICAgICAgICA6IGA6JHtsb2NhdGlvbi5wb3J0fWBcbiAgICAgICAgICAgIDogYDoke2FwaVBvcnR9YFxuICAgICAgICA6ICcnO1xuICAgIHJldHVybiBgJHtob3N0fSR7cG9ydH1gO1xufVxuIl19

package/esm2022/core/data/utils/is-entity-create-or-update-mutation.mjs

@@ -0,0 +1,45 @@
+import { getOperationAST } from 'graphql';
+const CREATE_ENTITY_REGEX = /Create([A-Za-z]+)Input/;
+const UPDATE_ENTITY_REGEX = /Update([A-Za-z]+)Input/;
+/**
+ * Checks the current documentNode for an operation with a variable named "Create<Entity>Input" or "Update<Entity>Input"
+ * and if a match is found, returns the <Entity> name.
+ */
+export function isEntityCreateOrUpdateMutation(documentNode) {
+    const operationDef = getOperationAST(documentNode, null);
+    if (operationDef && operationDef.variableDefinitions) {
+        for (const variableDef of operationDef.variableDefinitions) {
+            const namedType = extractInputType(variableDef.type);
+            const inputTypeName = namedType.name.value;
+            // special cases which don't follow the usual pattern
+            if (inputTypeName === 'UpdateActiveAdministratorInput') {
+                return 'Administrator';
+            }
+            if (inputTypeName === 'ModifyOrderInput') {
+                return 'Order';
+            }
+            if (inputTypeName === 'AddItemToDraftOrderInput' ||
+                inputTypeName === 'AdjustDraftOrderLineInput') {
+                return 'OrderLine';
+            }
+            const createMatch = inputTypeName.match(CREATE_ENTITY_REGEX);
+            if (createMatch) {
+                return createMatch[1];
+            }
+            const updateMatch = inputTypeName.match(UPDATE_ENTITY_REGEX);
+            if (updateMatch) {
+                return updateMatch[1];
+            }
+        }
+    }
+}
+function extractInputType(type) {
+    if (type.kind === 'NonNullType') {
+        return extractInputType(type.type);
+    }
+    if (type.kind === 'ListType') {
+        return extractInputType(type.type);
+    }
+    return type;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/utils/remove-readonly-custom-fields.mjs

@@ -0,0 +1,30 @@
+/**
+ * Removes any `readonly` custom fields from an entity (including its translations).
+ * To be used before submitting the entity for a create or update request.
+ */
+export function removeReadonlyCustomFields(variables, customFieldConfig) {
+    if (Array.isArray(variables)) {
+        return variables.map(variable => removeReadonlyCustomFields(variable, customFieldConfig));
+    }
+    if ('input' in variables && variables.input) {
+        if (Array.isArray(variables.input)) {
+            variables.input = variables.input.map(variable => removeReadonly(variable, customFieldConfig));
+        }
+        else {
+            variables.input = removeReadonly(variables.input, customFieldConfig);
+        }
+        return variables;
+    }
+    return removeReadonly(variables, customFieldConfig);
+}
+function removeReadonly(input, customFieldConfig) {
+    const readonlyConfigs = customFieldConfig.filter(({ readonly }) => readonly);
+    readonlyConfigs.forEach(({ name }) => {
+        input.translations?.forEach(translation => {
+            delete translation.customFields?.[name];
+        });
+        delete input.customFields?.[name];
+    });
+    return input;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/data/utils/transform-relation-custom-field-inputs.mjs

@@ -0,0 +1,46 @@
+import { getGraphQlInputName } from '@deenruv/common/lib/shared-utils';
+/**
+ * Transforms any custom field "relation" type inputs into the corresponding `<name>Id` format,
+ * as expected by the server.
+ */
+export function transformRelationCustomFieldInputs(variables, customFieldConfig) {
+    if (variables.input) {
+        if (Array.isArray(variables.input)) {
+            for (const item of variables.input) {
+                transformRelations(item, customFieldConfig);
+            }
+        }
+        else {
+            transformRelations(variables.input, customFieldConfig);
+        }
+    }
+    return transformRelations(variables, customFieldConfig);
+}
+/**
+ * @description
+ * When persisting custom fields, we need to send just the IDs of the relations,
+ * rather than the objects themselves.
+ */
+function transformRelations(input, customFieldConfig) {
+    for (const field of customFieldConfig) {
+        if (field.type === 'relation') {
+            if (hasCustomFields(input)) {
+                const entityValue = input.customFields[field.name];
+                if (input.customFields.hasOwnProperty(field.name)) {
+                    delete input.customFields[field.name];
+                    input.customFields[getGraphQlInputName(field)] =
+                        field.list && Array.isArray(entityValue)
+                            ? entityValue.map(v => (typeof v === 'string' ? v : v?.id))
+                            : entityValue === null
+                                ? null
+                                : entityValue?.id;
+                }
+            }
+        }
+    }
+    return input;
+}
+function hasCustomFields(input) {
+    return input != null && input.hasOwnProperty('customFields') && typeof input.customFields === 'object';
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/deenruv-admin-ui-core.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVlbnJ1di1hZG1pbi11aS1jb3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9jb3JlL3NyYy9kZWVucnV2LWFkbWluLXVpLWNvcmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWNfYXBpJztcbiJdfQ==

package/esm2022/core/extension/add-action-bar-dropdown-menu-item.mjs

@@ -0,0 +1,35 @@
+import { APP_INITIALIZER } from '@angular/core';
+import { NavBuilderService } from '../providers/nav-builder/nav-builder.service';
+/**
+ * @description
+ * Adds a dropdown menu item to the ActionBar at the top right of each list or detail view. The locationId can
+ * be determined by pressing `ctrl + u` when running the Admin UI in dev mode.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { addActionBarDropdownMenuItem } from '\@deenruv/admin-ui/core';
+ *
+ * export default [
+ *     addActionBarDropdownMenuItem({
+ *         id: 'print-invoice',
+ *         label: 'Print Invoice',
+ *         locationId: 'order-detail',
+ *         routerLink: ['/extensions/invoicing'],
+ *     }),
+ * ];
+ * ```
+ *
+ * @since 2.2.0
+ * @docsCategory action-bar
+ */
+export function addActionBarDropdownMenuItem(config) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addActionBarDropdownMenuItem(config);
+        },
+        deps: [NavBuilderService],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/extension/add-action-bar-item.mjs

@@ -0,0 +1,31 @@
+import { APP_INITIALIZER } from '@angular/core';
+import { NavBuilderService } from '../providers/nav-builder/nav-builder.service';
+/**
+ * @description
+ * Adds a button to the ActionBar at the top right of each list or detail view. The locationId can
+ * be determined by pressing `ctrl + u` when running the Admin UI in dev mode.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * export default [
+ *     addActionBarItem({
+ *         id: 'print-invoice',
+ *         label: 'Print Invoice',
+ *         locationId: 'order-detail',
+ *         routerLink: ['/extensions/invoicing'],
+ *     }),
+ * ];
+ * ```
+ * @docsCategory action-bar
+ */
+export function addActionBarItem(config) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addActionBarItem(config);
+        },
+        deps: [NavBuilderService],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/extension/add-nav-menu-item.mjs

@@ -0,0 +1,75 @@
+import { APP_INITIALIZER } from '@angular/core';
+import { NavBuilderService } from '../providers/nav-builder/nav-builder.service';
+/**
+ * @description
+ * Add a section to the main nav menu. Providing the `before` argument will
+ * move the section before any existing section with the specified id. If
+ * omitted (or if the id is not found) the section will be appended to the
+ * existing set of sections.
+ * This should be used in the NgModule `providers` array of your ui extension module.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { addNavMenuSection } from '\@deenruv/admin-ui/core';
+ *
+ * export default [
+ *     addNavMenuSection({
+ *         id: 'reports',
+ *         label: 'Reports',
+ *         items: [{
+ *             // ...
+ *         }],
+ *     },
+ *     'settings'),
+ * ];
+ * ```
+ * @docsCategory nav-menu
+ */
+export function addNavMenuSection(config, before) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addNavMenuSection(config, before);
+        },
+        deps: [NavBuilderService],
+    };
+}
+/**
+ * @description
+ * Add a menu item to an existing section specified by `sectionId`. The id of the section
+ * can be found by inspecting the DOM and finding the `data-section-id` attribute.
+ * Providing the `before` argument will move the item before any existing item with the specified id.
+ * If omitted (or if the name is not found) the item will be appended to the
+ * end of the section.
+ *
+ * This should be used in the NgModule `providers` array of your ui extension module.
+ *
+ * @example
+ * ```ts title="providers.ts"
+ * import { addNavMenuItem } from '\@deenruv/admin-ui/core';
+ *
+ * export default [
+ *     addNavMenuItem({
+ *         id: 'reviews',
+ *         label: 'Product Reviews',
+ *         routerLink: ['/extensions/reviews'],
+ *         icon: 'star',
+ *     },
+ *     'marketing'),
+ * ];
+ * ```
+ *
+ * @docsCategory nav-menu
+ */
+export function addNavMenuItem(config, sectionId, before) {
+    return {
+        provide: APP_INITIALIZER,
+        multi: true,
+        useFactory: (navBuilderService) => () => {
+            navBuilderService.addNavMenuItem(config, sectionId, before);
+        },
+        deps: [NavBuilderService],
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/extension/components/angular-route.component.mjs

@@ -0,0 +1,67 @@
+import { Component, EventEmitter, inject, Input, Output, } from '@angular/core';
+import { SharedModule } from '../../shared/shared.module';
+import { ROUTE_COMPONENT_OPTIONS, RouteComponent } from './route.component';
+import * as i0 from "@angular/core";
+/**
+ * @description
+ * This component is used internally to allow us to dynamically load a component
+ * like with `*ngComponentOutlet`, but with the ability to get a reference to the
+ * created ComponentRef. This can then be used to delegate lifecycle events like
+ * `canDeactivate` to the loaded component.
+ */
+export class DynamicComponentLoaderComponent {
+    constructor(viewContainer) {
+        this.viewContainer = viewContainer;
+        this.loaded = new EventEmitter();
+    }
+    ngOnInit() {
+        const componentRef = this.viewContainer.createComponent(this.componentType);
+        this.loaded.emit(componentRef);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DynamicComponentLoaderComponent, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: DynamicComponentLoaderComponent, isStandalone: true, selector: "vdr-dynamic-component-loader", inputs: { componentType: "componentType" }, outputs: { loaded: "loaded" }, ngImport: i0, template: ``, isInline: true, dependencies: [{ kind: "ngmodule", type: SharedModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DynamicComponentLoaderComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vdr-dynamic-component-loader',
+                    template: ``,
+                    standalone: true,
+                    imports: [SharedModule],
+                }]
+        }], ctorParameters: () => [{ type: i0.ViewContainerRef }], propDecorators: { componentType: [{
+                type: Input
+            }], loaded: [{
+                type: Output
+            }] } });
+export class AngularRouteComponent {
+    constructor() {
+        this.component = inject(ROUTE_COMPONENT_OPTIONS).component;
+    }
+    componentLoaded(componentRef) {
+        this.componentRef = componentRef;
+    }
+    canDeactivate() {
+        return this.componentRef?.instance?.canDeactivate?.();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularRouteComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: AngularRouteComponent, isStandalone: true, selector: "vdr-angular-route-component", ngImport: i0, template: `
+        <vdr-route-component>
+            <vdr-dynamic-component-loader [componentType]="component" (loaded)="componentLoaded($event)" />
+        </vdr-route-component>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: SharedModule }, { kind: "component", type: RouteComponent, selector: "vdr-route-component", inputs: ["locationId", "description"] }, { kind: "component", type: DynamicComponentLoaderComponent, selector: "vdr-dynamic-component-loader", inputs: ["componentType"], outputs: ["loaded"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AngularRouteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vdr-angular-route-component',
+                    template: `
+        <vdr-route-component>
+            <vdr-dynamic-component-loader [componentType]="component" (loaded)="componentLoaded($event)" />
+        </vdr-route-component>
+    `,
+                    standalone: true,
+                    imports: [SharedModule, RouteComponent, DynamicComponentLoaderComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/extension/components/route.component.mjs

@@ -0,0 +1,80 @@
+import { Component, inject, InjectionToken, Input } from '@angular/core';
+import { notNullOrUndefined } from '@deenruv/common/lib/shared-utils';
+import { combineLatest, Observable, of, switchMap } from 'rxjs';
+import { filter, map } from 'rxjs/operators';
+import { SharedModule } from '../../shared/shared.module';
+import { PageMetadataService } from '../providers/page-metadata.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../providers/page/page.service";
+import * as i3 from "@angular/common";
+import * as i4 from "../../shared/components/page-header/page-header.component";
+import * as i5 from "../../shared/components/page-title/page-title.component";
+import * as i6 from "../../shared/components/page-header-description/page-header-description.component";
+import * as i7 from "../../shared/components/page-header-tabs/page-header-tabs.component";
+import * as i8 from "../../shared/components/page-body/page-body.component";
+export const ROUTE_COMPONENT_OPTIONS = new InjectionToken('ROUTE_COMPONENT_OPTIONS');
+export class RouteComponent {
+    constructor(route, pageService) {
+        this.route = route;
+        this.pageService = pageService;
+        this.headerTabs = [];
+        const breadcrumbLabel$ = this.route.data.pipe(switchMap(data => {
+            if (data.breadcrumb instanceof Observable) {
+                return data.breadcrumb;
+            }
+            if (typeof data.breadcrumb === 'function') {
+                return data.breadcrumb(data);
+            }
+            return of(undefined);
+        }), filter(notNullOrUndefined), map(breadcrumb => {
+            if (typeof breadcrumb === 'string') {
+                return breadcrumb;
+            }
+            if (Array.isArray(breadcrumb)) {
+                return breadcrumb[breadcrumb.length - 1].label;
+            }
+            return breadcrumb.label;
+        }));
+        this.title$ = combineLatest([inject(ROUTE_COMPONENT_OPTIONS).title$, breadcrumbLabel$]).pipe(map(([title, breadcrumbLabel]) => title ?? breadcrumbLabel));
+        this.locationId = this.route.snapshot.data.locationId;
+        this.description = this.route.snapshot.data.description;
+        this.headerTabs = this.pageService.getPageTabs(this.locationId).map(tab => ({
+            id: tab.tab,
+            label: tab.tab,
+            icon: tab.tabIcon,
+            route: tab.route ? [tab.route] : ['./'],
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteComponent, deps: [{ token: i1.ActivatedRoute }, { token: i2.PageService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: RouteComponent, isStandalone: true, selector: "vdr-route-component", inputs: { locationId: "locationId", description: "description" }, providers: [PageMetadataService], ngImport: i0, template: `
+        <vdr-page-header>
+            <vdr-page-title *ngIf="title$ | async as title" [title]="title"></vdr-page-title>
+            <vdr-page-header-description *ngIf="description">{{ description }}</vdr-page-header-description>
+            <vdr-page-header-tabs *ngIf="headerTabs.length > 1" [tabs]="headerTabs"></vdr-page-header-tabs>
+        </vdr-page-header>
+        <vdr-page-body><ng-content /></vdr-page-body>
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: SharedModule }, { kind: "directive", type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4.PageHeaderComponent, selector: "vdr-page-header" }, { kind: "component", type: i5.PageTitleComponent, selector: "vdr-page-title", inputs: ["title"] }, { kind: "component", type: i6.PageHeaderDescriptionComponent, selector: "vdr-page-header-description" }, { kind: "component", type: i7.PageHeaderTabsComponent, selector: "vdr-page-header-tabs", inputs: ["tabs"] }, { kind: "component", type: i8.PageBodyComponent, selector: "vdr-page-body" }, { kind: "pipe", type: i3.AsyncPipe, name: "async" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RouteComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'vdr-route-component',
+                    template: `
+        <vdr-page-header>
+            <vdr-page-title *ngIf="title$ | async as title" [title]="title"></vdr-page-title>
+            <vdr-page-header-description *ngIf="description">{{ description }}</vdr-page-header-description>
+            <vdr-page-header-tabs *ngIf="headerTabs.length > 1" [tabs]="headerTabs"></vdr-page-header-tabs>
+        </vdr-page-header>
+        <vdr-page-body><ng-content /></vdr-page-body>
+    `,
+                    standalone: true,
+                    imports: [SharedModule],
+                    providers: [PageMetadataService],
+                }]
+        }], ctorParameters: () => [{ type: i1.ActivatedRoute }, { type: i2.PageService }], propDecorators: { locationId: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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