@iapps/ng-dhis2-ui 1.0.0

package/esm2022/lib/modules/header-bar/utils/profile-menu/profile-header.mjs

@@ -0,0 +1,95 @@
+import { UserAvatar } from '@dhis2-ui/user-avatar';
+import { useConfig } from '@dhis2/app-runtime';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { joinPath } from '../join-path';
+import i18n from '@dhis2/d2-i18n';
+const ProfileName = (params) => {
+    const { children } = params;
+    return (React.createElement("div", { className: "headerbar-profile-username", "data-test": "headerbar-profile-username" },
+        children,
+        React.createElement("style", { jsx: true }, `
+            .headerbar-profile-username {
+                margin-bottom: 3px;
+                font-size: 16px;
+                line-height: 19px;
+            }
+        `)));
+};
+ProfileName.propTypes = {
+    children: PropTypes.string,
+};
+const ProfileEmail = (params) => {
+    const { children } = params;
+    return (React.createElement("div", { className: "headerbar-profile-user-email", "data-test": "headerbar-profile-user-email" },
+        children,
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile-user-email {
+                    margin-bottom: 6px;
+                    font-size: 14px;
+                    line-height: 16px;
+                }
+            `)));
+};
+ProfileEmail.propTypes = {
+    children: PropTypes.string,
+};
+const ProfileEdit = (params) => {
+    const { children } = params;
+    const { baseUrl } = useConfig();
+    return (React.createElement("a", { className: "headerbar-profile-edit-profile-link", href: joinPath(baseUrl, 'dhis-web-user-profile/#/profile'), "data-test": "headerbar-profile-edit-profile-link" },
+        children,
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile-edit-profile-link {
+                    color: rgba(0, 0, 0, 0.87);
+                    font-size: 12px;
+                    line-height: 14px;
+                    text-decoration: underline !important;
+                    cursor: pointer;
+                }
+            `)));
+};
+ProfileEdit.propTypes = {
+    children: PropTypes.string,
+};
+const ProfileDetails = (params) => {
+    const { name, email } = params;
+    return (React.createElement("div", { className: "headerbar-profile-details" },
+        React.createElement(ProfileName, null, name),
+        React.createElement(ProfileEmail, null, email),
+        React.createElement(ProfileEdit, null, i18n.t('Edit profile')),
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile-details {
+                    display: flex;
+                    flex-direction: column;
+                    margin-left: 20px;
+                    color: #000;
+                    font-size: 14px;
+                    font-weight: 400;
+                }
+            `)));
+};
+ProfileDetails.propTypes = {
+    email: PropTypes.string,
+    name: PropTypes.string,
+};
+export const ProfileHeader = (params) => {
+    const { name, email, avatarId } = params;
+    return (React.createElement("div", { className: "headerbar-profile-header" },
+        React.createElement(UserAvatar, { avatarId: avatarId, name: name, dataTest: "headerbar-profile-menu-icon", large: true }),
+        React.createElement(ProfileDetails, { name: name, email: email }),
+        React.createElement("style", { jsx: true }, `
+            .headerbar-profile-header {
+                display: flex;
+                flex-direction: row;
+                margin-left: 24px;
+                padding-top: 20px;
+            }
+        `)));
+};
+ProfileHeader.propTypes = {
+    avatarId: PropTypes.string,
+    email: PropTypes.string,
+    name: PropTypes.string,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"profile-header.js","sourceRoot":"","sources":["../../../../../../../../ng-dhis2-ui/src/lib/modules/header-bar/utils/profile-menu/profile-header.tsx"],"names":[],"mappings":"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","sourcesContent":["import { UserAvatar } from '@dhis2-ui/user-avatar'\nimport { useConfig } from '@dhis2/app-runtime'\nimport PropTypes from 'prop-types'\nimport React from 'react'\nimport { joinPath } from '../join-path'\nimport i18n from '@dhis2/d2-i18n'\ndeclare module 'react' {\n    interface StyleHTMLAttributes<T> extends React.HTMLAttributes<T> {\n      jsx?: boolean;\n      global?: boolean;\n    }\n  }\n\nconst ProfileName = (params: any) => {\n    const { children } = params;\n    return  (\n    <div className=\"headerbar-profile-username\" data-test=\"headerbar-profile-username\">\n        {children}\n\n        <style jsx>{`\n            .headerbar-profile-username {\n                margin-bottom: 3px;\n                font-size: 16px;\n                line-height: 19px;\n            }\n        `}</style>\n    </div>\n) }\nProfileName.propTypes = {\n    children: PropTypes.string,\n}\n\nconst ProfileEmail = (params: any) => {\n    const { children } = params;\n    return (\n        <div className=\"headerbar-profile-user-email\" data-test=\"headerbar-profile-user-email\">\n            {children}\n    \n            <style jsx>{`\n                .headerbar-profile-user-email {\n                    margin-bottom: 6px;\n                    font-size: 14px;\n                    line-height: 16px;\n                }\n            `}</style>\n        </div>\n    )\n}\nProfileEmail.propTypes = {\n    children: PropTypes.string,\n}\n\nconst ProfileEdit = (params: any) => {\n    const { children } = params;\n    const { baseUrl } = useConfig()\n\n    return (\n        <a\n            className=\"headerbar-profile-edit-profile-link\"\n            href={joinPath(baseUrl, 'dhis-web-user-profile/#/profile')}\n            data-test=\"headerbar-profile-edit-profile-link\"\n        >\n            {children}\n\n            <style jsx>{`\n                .headerbar-profile-edit-profile-link {\n                    color: rgba(0, 0, 0, 0.87);\n                    font-size: 12px;\n                    line-height: 14px;\n                    text-decoration: underline !important;\n                    cursor: pointer;\n                }\n            `}</style>\n        </a>\n    )\n}\n\nProfileEdit.propTypes = {\n    children: PropTypes.string,\n}\n\nconst ProfileDetails = (params: any) => {\n    const { name, email } = params;\n    return (\n        <div className=\"headerbar-profile-details\">\n            <ProfileName>{name}</ProfileName>\n            <ProfileEmail>{email}</ProfileEmail>\n            <ProfileEdit>{i18n.t('Edit profile')}</ProfileEdit>\n    \n            <style jsx>{`\n                .headerbar-profile-details {\n                    display: flex;\n                    flex-direction: column;\n                    margin-left: 20px;\n                    color: #000;\n                    font-size: 14px;\n                    font-weight: 400;\n                }\n            `}</style>\n        </div>\n    )\n}\n\nProfileDetails.propTypes = {\n    email: PropTypes.string,\n    name: PropTypes.string,\n}\n\nexport const ProfileHeader = (params: any) => {\n    const { name, email, avatarId } = params;\n    return (<div className=\"headerbar-profile-header\">\n        <UserAvatar\n            avatarId={avatarId}\n            name={name}\n            dataTest=\"headerbar-profile-menu-icon\"\n            large\n        />\n        <ProfileDetails name={name} email={email} />\n\n        <style jsx>{`\n            .headerbar-profile-header {\n                display: flex;\n                flex-direction: row;\n                margin-left: 24px;\n                padding-top: 20px;\n            }\n        `}</style>\n    </div>\n) }\n\nProfileHeader.propTypes = {\n    avatarId: PropTypes.string,\n    email: PropTypes.string,\n    name: PropTypes.string,\n}\n"]}

package/esm2022/lib/modules/header-bar/utils/profile-menu/profile-menu.mjs

@@ -0,0 +1,101 @@
+import { Card } from '@dhis2-ui/card';
+import { Center } from '@dhis2-ui/center';
+import { Divider } from '@dhis2-ui/divider';
+import { Layer } from '@dhis2-ui/layer';
+import { CircularLoader } from '@dhis2-ui/loader';
+import { MenuDivider, MenuItem } from '@dhis2-ui/menu';
+import { clearSensitiveCaches, useConfig } from '@dhis2/app-runtime';
+import { colors } from '@dhis2/ui-constants';
+import { IconSettings24, IconInfo24, IconLogOut24, IconUser24, IconQuestion24, } from '@dhis2/ui-icons';
+import PropTypes from 'prop-types';
+import React, { useState } from 'react';
+import { DebugInfoMenuItem } from '../debug-info/debug-info-menu-item';
+import { joinPath } from '../join-path';
+import i18n from '@dhis2/d2-i18n';
+import { ProfileHeader } from './profile-header';
+import { UpdateNotification } from './update-notification';
+const LoadingMask = () => (React.createElement(Layer, { translucent: true, disablePortal: true, dataTest: "headerbar-profile-menu-loading-mask" },
+    React.createElement(Center, null,
+        React.createElement(CircularLoader, null))));
+const ProfileContents = (params) => {
+    const { name, email, avatarId, helpUrl, hideProfileMenu, showDebugInfoModal, } = params;
+    const { baseUrl } = useConfig();
+    const [loading, setLoading] = useState(false);
+    return (React.createElement(Card, null,
+        React.createElement("div", { className: "headerbar-profile-contents" },
+            React.createElement(ProfileHeader, { name: name, email: email, avatarId: avatarId }),
+            React.createElement(Divider, { margin: "13px 0 7px 0" }),
+            React.createElement("ul", { "data-test": "headerbar-profile-menu" },
+                React.createElement(MenuItem, { href: joinPath(baseUrl, 'dhis-web-user-profile/#/settings'), label: i18n.t('Settings'), value: "settings", icon: React.createElement(IconSettings24, { color: colors.grey700 }) }),
+                React.createElement(MenuItem, { href: joinPath(baseUrl, 'dhis-web-user-profile/#/account'), label: i18n.t('Account'), value: "account", icon: React.createElement(IconUser24, { color: colors.grey700 }) }),
+                helpUrl && (React.createElement(MenuItem, { href: helpUrl, label: i18n.t('Help'), value: "help", icon: React.createElement(IconQuestion24, { color: colors.grey700 }) })),
+                React.createElement(MenuItem, { href: joinPath(baseUrl, 'dhis-web-user-profile/#/aboutPage'), label: i18n.t('About DHIS2'), value: "about", icon: React.createElement(IconInfo24, { color: colors.grey700 }) }),
+                React.createElement(MenuItem, { href: joinPath(baseUrl, 'dhis-web-commons-security/logout.action'), 
+                    // NB: By MenuItem implementation, this callback
+                    // overwrites default navigation behavior but maintains
+                    // the href attribute
+                    onClick: async () => {
+                        setLoading(true);
+                        await clearSensitiveCaches();
+                        setLoading(false);
+                        window.location.assign(joinPath(baseUrl, 'dhis-web-commons-security/logout.action'));
+                    }, label: i18n.t('Logout'), value: "logout", icon: React.createElement(IconLogOut24, { color: colors.grey700 }) }),
+                React.createElement(MenuDivider, { dense: true }),
+                React.createElement(DebugInfoMenuItem, { hideProfileMenu: hideProfileMenu, showDebugInfoModal: showDebugInfoModal }),
+                React.createElement(UpdateNotification, { hideProfileMenu: hideProfileMenu }))),
+        loading && React.createElement(LoadingMask, null),
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile-contents {
+                    width: 100%;
+                    padding: 0;
+                }
+
+                .headerbar-profile-contents ul {
+                    padding: 0;
+                    margin: 0;
+                }
+
+                .headerbar-profile-contents a {
+                    display: inline-flex !important;
+                }
+
+               .headerbar-profile-contents a,
+               .headerbar-profile-contents a:hover,
+               .headerbar-profile-contents a:focus,
+               .headerbar-profile-contents a:active,
+               .headerbar-profile-contents a:visited {
+                    text-decoration: none;
+                    display: block;
+                }
+            `)));
+};
+ProfileContents.propTypes = {
+    hideProfileMenu: PropTypes.func.isRequired,
+    showDebugInfoModal: PropTypes.func.isRequired,
+    avatarId: PropTypes.string,
+    email: PropTypes.string,
+    helpUrl: PropTypes.string,
+    name: PropTypes.string,
+};
+export const ProfileMenu = (params) => {
+    const { ...props } = params;
+    return (React.createElement("div", { className: "headerbar-profile-menu", "data-test": "headerbar-profile-menu" },
+        React.createElement(ProfileContents, { ...props }),
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile-menu {
+                    z-index: 10000;
+                    position: absolute;
+                    right: 4px;
+                    width: 320px;
+                }
+            `)));
+};
+ProfileMenu.propTypes = {
+    hideProfileMenu: PropTypes.func.isRequired,
+    showDebugInfoModal: PropTypes.func.isRequired,
+    avatarId: PropTypes.string,
+    email: PropTypes.string,
+    helpUrl: PropTypes.string,
+    name: PropTypes.string,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"profile-menu.js","sourceRoot":"","sources":["../../../../../../../../ng-dhis2-ui/src/lib/modules/header-bar/utils/profile-menu/profile-menu.tsx"],"names":[],"mappings":"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","sourcesContent":["import { Card } from '@dhis2-ui/card'\nimport { Center } from '@dhis2-ui/center'\nimport { Divider } from '@dhis2-ui/divider'\nimport { Layer } from '@dhis2-ui/layer'\nimport { CircularLoader } from '@dhis2-ui/loader'\nimport { MenuDivider, MenuItem } from '@dhis2-ui/menu'\nimport { clearSensitiveCaches, useConfig } from '@dhis2/app-runtime'\nimport { colors } from '@dhis2/ui-constants'\nimport {\n    IconSettings24,\n    IconInfo24,\n    IconLogOut24,\n    IconUser24,\n    IconQuestion24,\n} from '@dhis2/ui-icons'\nimport PropTypes from 'prop-types'\nimport React, { useState } from 'react'\nimport { DebugInfoMenuItem } from '../debug-info/debug-info-menu-item'\nimport { joinPath } from '../join-path'\nimport i18n from '@dhis2/d2-i18n';\nimport { ProfileHeader } from './profile-header'\nimport { UpdateNotification } from './update-notification'\n\nconst LoadingMask = () => (\n    <Layer\n        translucent\n        disablePortal\n        dataTest=\"headerbar-profile-menu-loading-mask\"\n    >\n        <Center>\n            <CircularLoader />\n        </Center>\n    </Layer>\n)\n\nconst ProfileContents = (params: any) => {\n    const {\n        name,\n        email,\n        avatarId,\n        helpUrl,\n        hideProfileMenu,\n        showDebugInfoModal,\n    } = params;\n    const { baseUrl } = useConfig()\n    const [loading, setLoading] = useState(false)\n\n    return (\n        <Card>\n            <div className=\"headerbar-profile-contents\">\n                <ProfileHeader name={name} email={email} avatarId={avatarId} />\n                <Divider margin=\"13px 0 7px 0\" />\n                <ul data-test=\"headerbar-profile-menu\">\n                    <MenuItem\n                        href={joinPath(\n                            baseUrl,\n                            'dhis-web-user-profile/#/settings'\n                        )}\n                        label={i18n.t('Settings')}\n                        value=\"settings\"\n                        icon={<IconSettings24 color={colors.grey700} />}\n                    />\n                    <MenuItem\n                        href={joinPath(\n                            baseUrl,\n                            'dhis-web-user-profile/#/account'\n                        )}\n                        label={i18n.t('Account')}\n                        value=\"account\"\n                        icon={<IconUser24 color={colors.grey700} />}\n                    />\n                    {helpUrl && (\n                        <MenuItem\n                            href={helpUrl}\n                            label={i18n.t('Help')}\n                            value=\"help\"\n                            icon={<IconQuestion24 color={colors.grey700} />}\n                        />\n                    )}\n                    <MenuItem\n                        href={joinPath(\n                            baseUrl,\n                            'dhis-web-user-profile/#/aboutPage'\n                        )}\n                        label={i18n.t('About DHIS2')}\n                        value=\"about\"\n                        icon={<IconInfo24 color={colors.grey700} />}\n                    />\n                    <MenuItem\n                        href={joinPath(\n                            baseUrl,\n                            'dhis-web-commons-security/logout.action'\n                        )}\n                        // NB: By MenuItem implementation, this callback\n                        // overwrites default navigation behavior but maintains\n                        // the href attribute\n                        onClick={async () => {\n                            setLoading(true)\n                            await clearSensitiveCaches()\n                            setLoading(false)\n                            window.location.assign(\n                                joinPath(\n                                    baseUrl,\n                                    'dhis-web-commons-security/logout.action'\n                                )\n                            )\n                        }}\n                        label={i18n.t('Logout')}\n                        value=\"logout\"\n                        icon={<IconLogOut24 color={colors.grey700} />}\n                    />\n                    <MenuDivider dense />\n                    <DebugInfoMenuItem\n                        hideProfileMenu={hideProfileMenu}\n                        showDebugInfoModal={showDebugInfoModal}\n                    />\n                    <UpdateNotification hideProfileMenu={hideProfileMenu} />\n                </ul>\n            </div>\n\n            {loading && <LoadingMask />}\n\n            <style jsx>{`\n                .headerbar-profile-contents {\n                    width: 100%;\n                    padding: 0;\n                }\n\n                .headerbar-profile-contents ul {\n                    padding: 0;\n                    margin: 0;\n                }\n\n                .headerbar-profile-contents a {\n                    display: inline-flex !important;\n                }\n\n               .headerbar-profile-contents a,\n               .headerbar-profile-contents a:hover,\n               .headerbar-profile-contents a:focus,\n               .headerbar-profile-contents a:active,\n               .headerbar-profile-contents a:visited {\n                    text-decoration: none;\n                    display: block;\n                }\n            `}</style>\n        </Card>\n    )\n}\n\nProfileContents.propTypes = {\n    hideProfileMenu: PropTypes.func.isRequired,\n    showDebugInfoModal: PropTypes.func.isRequired,\n    avatarId: PropTypes.string,\n    email: PropTypes.string,\n    helpUrl: PropTypes.string,\n    name: PropTypes.string,\n}\n\nexport const ProfileMenu = (params: any) => {\n    const { ...props }=params;\n    return (\n        <div className=\"headerbar-profile-menu\" data-test=\"headerbar-profile-menu\">\n            <ProfileContents {...props} />\n            <style jsx>{`\n                .headerbar-profile-menu {\n                    z-index: 10000;\n                    position: absolute;\n                    right: 4px;\n                    width: 320px;\n                }\n            `}</style>\n        </div>\n    )\n}\n\nProfileMenu.propTypes = {\n    hideProfileMenu: PropTypes.func.isRequired,\n    showDebugInfoModal: PropTypes.func.isRequired,\n    avatarId: PropTypes.string,\n    email: PropTypes.string,\n    helpUrl: PropTypes.string,\n    name: PropTypes.string,\n}\n"]}

package/esm2022/lib/modules/header-bar/utils/profile-menu/update-notification.mjs

@@ -0,0 +1,54 @@
+import { MenuItem } from '@dhis2-ui/menu';
+import { useConfig } from '@dhis2/app-runtime';
+import { colors } from '@dhis2/ui-constants';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { useHeaderBarContext } from '../header-bar-context';
+import i18n from '@dhis2/d2-i18n';
+export function UpdateNotification(params) {
+    const { hideProfileMenu } = params;
+    const { appName } = useConfig();
+    const { updateAvailable, onApplyAvailableUpdate } = useHeaderBarContext();
+    const onClick = () => {
+        hideProfileMenu();
+        onApplyAvailableUpdate?.();
+    };
+    const updateNotificationLabel = (React.createElement("div", { className: "root" },
+        React.createElement("div", { className: "badge" }),
+        React.createElement("div", { className: "spacer" }),
+        React.createElement("div", { className: "message" },
+            appName
+                ? i18n.t('New {{appName}} version available', { appName })
+                : i18n.t('New app version available'),
+            React.createElement("br", null),
+            i18n.t('Click to reload')),
+        React.createElement("style", { jsx: true }, `
+                .root {
+                    display: flex;
+                    flex-direction: row;
+                    align-items: center;
+                    font-size: 14px;
+                    line-height: 17px;
+                }
+                .badge {
+                    display: inline-block;
+                    width: 12px;
+                    height: 12px;
+                    margin: 0 8px;
+                    border-radius: 6px;
+                    background-color: ${colors.blue600};
+                }
+                .spacer {
+                    display: inline-block;
+                    width: 8px;
+                }
+                .message {
+                    display: inline-block;
+                }
+            `)));
+    return updateAvailable ? (React.createElement(MenuItem, { dense: true, onClick: onClick, label: updateNotificationLabel, dataTest: "dhis2-ui-headerbar-updatenotification" })) : null;
+}
+UpdateNotification.propTypes = {
+    hideProfileMenu: PropTypes.func.isRequired,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlLW5vdGlmaWNhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL25nLWRoaXMyLXVpL3NyYy9saWIvbW9kdWxlcy9oZWFkZXItYmFyL3V0aWxzL3Byb2ZpbGUtbWVudS91cGRhdGUtbm90aWZpY2F0aW9uLnRzeCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFDekMsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBQzlDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQTtBQUM1QyxPQUFPLFNBQVMsTUFBTSxZQUFZLENBQUE7QUFDbEMsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFBO0FBQ3pCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHVCQUF1QixDQUFBO0FBQzNELE9BQU8sSUFBSSxNQUFNLGdCQUFnQixDQUFBO0FBUWpDLE1BQU0sVUFBVSxrQkFBa0IsQ0FBQyxNQUFXO0lBQzFDLE1BQU0sRUFBRSxlQUFlLEVBQUUsR0FBRSxNQUFNLENBQUM7SUFDbEMsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLFNBQVMsRUFBRSxDQUFBO0lBQy9CLE1BQU0sRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsR0FBRyxtQkFBbUIsRUFBRSxDQUFBO0lBQ3pFLE1BQU0sT0FBTyxHQUFHLEdBQUcsRUFBRTtRQUNqQixlQUFlLEVBQUUsQ0FBQTtRQUNqQixzQkFBc0IsRUFBRSxFQUFFLENBQUE7SUFDOUIsQ0FBQyxDQUFBO0lBRUQsTUFBTSx1QkFBdUIsR0FBRyxDQUM1Qiw2QkFBSyxTQUFTLEVBQUMsTUFBTTtRQUNqQiw2QkFBSyxTQUFTLEVBQUMsT0FBTyxHQUFHO1FBQ3pCLDZCQUFLLFNBQVMsRUFBQyxRQUFRLEdBQUc7UUFDMUIsNkJBQUssU0FBUyxFQUFDLFNBQVM7WUFDbkIsT0FBTztnQkFDSixDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxtQ0FBbUMsRUFBRSxFQUFFLE9BQU8sRUFBRSxDQUFDO2dCQUMxRCxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQywyQkFBMkIsQ0FBQztZQUN6QywrQkFBTTtZQUNMLElBQUksQ0FBQyxDQUFDLENBQUMsaUJBQWlCLENBQUMsQ0FDeEI7UUFDTiwrQkFBTyxHQUFHLFVBQUU7Ozs7Ozs7Ozs7Ozs7O3dDQWNnQixNQUFNLENBQUMsT0FBTzs7Ozs7Ozs7O2FBU3pDLENBQVMsQ0FDUixDQUNULENBQUE7SUFFRCxPQUFPLGVBQWUsQ0FBQyxDQUFDLENBQUMsQ0FDckIsb0JBQUMsUUFBUSxJQUNMLEtBQUssUUFDTCxPQUFPLEVBQUUsT0FBTyxFQUNoQixLQUFLLEVBQUUsdUJBQXVCLEVBQzlCLFFBQVEsRUFBQyx1Q0FBdUMsR0FDbEQsQ0FDTCxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUE7QUFDWixDQUFDO0FBRUQsa0JBQWtCLENBQUMsU0FBUyxHQUFHO0lBQzNCLGVBQWUsRUFBRSxTQUFTLENBQUMsSUFBSSxDQUFDLFVBQVU7Q0FDN0MsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSAnQGRoaXMyLXVpL21lbnUnXG5pbXBvcnQgeyB1c2VDb25maWcgfSBmcm9tICdAZGhpczIvYXBwLXJ1bnRpbWUnXG5pbXBvcnQgeyBjb2xvcnMgfSBmcm9tICdAZGhpczIvdWktY29uc3RhbnRzJ1xuaW1wb3J0IFByb3BUeXBlcyBmcm9tICdwcm9wLXR5cGVzJ1xuaW1wb3J0IFJlYWN0IGZyb20gJ3JlYWN0J1xuaW1wb3J0IHsgdXNlSGVhZGVyQmFyQ29udGV4dCB9IGZyb20gJy4uL2hlYWRlci1iYXItY29udGV4dCdcbmltcG9ydCBpMThuIGZyb20gJ0BkaGlzMi9kMi1pMThuJ1xuZGVjbGFyZSBtb2R1bGUgJ3JlYWN0JyB7XG4gICAgaW50ZXJmYWNlIFN0eWxlSFRNTEF0dHJpYnV0ZXM8VD4gZXh0ZW5kcyBSZWFjdC5IVE1MQXR0cmlidXRlczxUPiB7XG4gICAgICBqc3g/OiBib29sZWFuO1xuICAgICAgZ2xvYmFsPzogYm9vbGVhbjtcbiAgICB9XG4gIH1cblxuZXhwb3J0IGZ1bmN0aW9uIFVwZGF0ZU5vdGlmaWNhdGlvbihwYXJhbXM6IGFueSkge1xuICAgIGNvbnN0IHsgaGlkZVByb2ZpbGVNZW51IH0gPXBhcmFtcztcbiAgICBjb25zdCB7IGFwcE5hbWUgfSA9IHVzZUNvbmZpZygpXG4gICAgY29uc3QgeyB1cGRhdGVBdmFpbGFibGUsIG9uQXBwbHlBdmFpbGFibGVVcGRhdGUgfSA9IHVzZUhlYWRlckJhckNvbnRleHQoKVxuICAgIGNvbnN0IG9uQ2xpY2sgPSAoKSA9PiB7XG4gICAgICAgIGhpZGVQcm9maWxlTWVudSgpXG4gICAgICAgIG9uQXBwbHlBdmFpbGFibGVVcGRhdGU/LigpXG4gICAgfVxuXG4gICAgY29uc3QgdXBkYXRlTm90aWZpY2F0aW9uTGFiZWwgPSAoXG4gICAgICAgIDxkaXYgY2xhc3NOYW1lPVwicm9vdFwiPlxuICAgICAgICAgICAgPGRpdiBjbGFzc05hbWU9XCJiYWRnZVwiIC8+XG4gICAgICAgICAgICA8ZGl2IGNsYXNzTmFtZT1cInNwYWNlclwiIC8+XG4gICAgICAgICAgICA8ZGl2IGNsYXNzTmFtZT1cIm1lc3NhZ2VcIj5cbiAgICAgICAgICAgICAgICB7YXBwTmFtZVxuICAgICAgICAgICAgICAgICAgICA/IGkxOG4udCgnTmV3IHt7YXBwTmFtZX19IHZlcnNpb24gYXZhaWxhYmxlJywgeyBhcHBOYW1lIH0pXG4gICAgICAgICAgICAgICAgICAgIDogaTE4bi50KCdOZXcgYXBwIHZlcnNpb24gYXZhaWxhYmxlJyl9XG4gICAgICAgICAgICAgICAgPGJyIC8+XG4gICAgICAgICAgICAgICAge2kxOG4udCgnQ2xpY2sgdG8gcmVsb2FkJyl9XG4gICAgICAgICAgICA8L2Rpdj5cbiAgICAgICAgICAgIDxzdHlsZSBqc3g+e2BcbiAgICAgICAgICAgICAgICAucm9vdCB7XG4gICAgICAgICAgICAgICAgICAgIGRpc3BsYXk6IGZsZXg7XG4gICAgICAgICAgICAgICAgICAgIGZsZXgtZGlyZWN0aW9uOiByb3c7XG4gICAgICAgICAgICAgICAgICAgIGFsaWduLWl0ZW1zOiBjZW50ZXI7XG4gICAgICAgICAgICAgICAgICAgIGZvbnQtc2l6ZTogMTRweDtcbiAgICAgICAgICAgICAgICAgICAgbGluZS1oZWlnaHQ6IDE3cHg7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIC5iYWRnZSB7XG4gICAgICAgICAgICAgICAgICAgIGRpc3BsYXk6IGlubGluZS1ibG9jaztcbiAgICAgICAgICAgICAgICAgICAgd2lkdGg6IDEycHg7XG4gICAgICAgICAgICAgICAgICAgIGhlaWdodDogMTJweDtcbiAgICAgICAgICAgICAgICAgICAgbWFyZ2luOiAwIDhweDtcbiAgICAgICAgICAgICAgICAgICAgYm9yZGVyLXJhZGl1czogNnB4O1xuICAgICAgICAgICAgICAgICAgICBiYWNrZ3JvdW5kLWNvbG9yOiAke2NvbG9ycy5ibHVlNjAwfTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgLnNwYWNlciB7XG4gICAgICAgICAgICAgICAgICAgIGRpc3BsYXk6IGlubGluZS1ibG9jaztcbiAgICAgICAgICAgICAgICAgICAgd2lkdGg6IDhweDtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgLm1lc3NhZ2Uge1xuICAgICAgICAgICAgICAgICAgICBkaXNwbGF5OiBpbmxpbmUtYmxvY2s7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgYH08L3N0eWxlPlxuICAgICAgICA8L2Rpdj5cbiAgICApXG5cbiAgICByZXR1cm4gdXBkYXRlQXZhaWxhYmxlID8gKFxuICAgICAgICA8TWVudUl0ZW1cbiAgICAgICAgICAgIGRlbnNlXG4gICAgICAgICAgICBvbkNsaWNrPXtvbkNsaWNrfVxuICAgICAgICAgICAgbGFiZWw9e3VwZGF0ZU5vdGlmaWNhdGlvbkxhYmVsfVxuICAgICAgICAgICAgZGF0YVRlc3Q9XCJkaGlzMi11aS1oZWFkZXJiYXItdXBkYXRlbm90aWZpY2F0aW9uXCJcbiAgICAgICAgLz5cbiAgICApIDogbnVsbFxufVxuXG5VcGRhdGVOb3RpZmljYXRpb24ucHJvcFR5cGVzID0ge1xuICAgIGhpZGVQcm9maWxlTWVudTogUHJvcFR5cGVzLmZ1bmMuaXNSZXF1aXJlZCxcbn1cbiJdfQ==

package/esm2022/lib/modules/header-bar/utils/profile.mjs

@@ -0,0 +1,58 @@
+import { UserAvatar } from '@dhis2-ui/user-avatar';
+import PropTypes from 'prop-types';
+import React, { useCallback, useRef, useState } from 'react';
+import { DebugInfoModal } from './debug-info/debug-info-modal';
+import { ProfileMenu } from './profile-menu';
+import { useOnDocClick } from './profile/use-on-doc-click';
+const Profile = (params) => {
+    const { name, email, avatarId, helpUrl } = params;
+    const [showProfileMenu, setShowProfileMenu] = useState(false);
+    const [showDebugInfoModal, setShowDebugInfoModal] = useState(false);
+    const hideProfileMenu = useCallback(() => setShowProfileMenu(false), [setShowProfileMenu]);
+    const toggleProfileMenu = useCallback(() => setShowProfileMenu((show) => !show), [setShowProfileMenu]);
+    const containerRef = useRef(null);
+    useOnDocClick(containerRef, hideProfileMenu);
+    return (React.createElement("div", { ref: containerRef, "data-test": "headerbar-profile", className: "headerbar-profile" },
+        React.createElement("button", { className: "headerbar-profile-btn", onClick: toggleProfileMenu },
+            React.createElement(UserAvatar, { avatarId: avatarId, name: name, dataTest: "headerbar-profile-icon", medium: true })),
+        showProfileMenu && (React.createElement(ProfileMenu, { avatarId: avatarId, name: name, email: email, helpUrl: helpUrl, hideProfileMenu: hideProfileMenu, showDebugInfoModal: () => {
+                setShowDebugInfoModal(true);
+            } })),
+        showDebugInfoModal && (React.createElement(DebugInfoModal, { onClose: () => {
+                setShowDebugInfoModal(false);
+            } })),
+        React.createElement("style", { jsx: true }, `
+                .headerbar-profile {
+                    position: relative;
+                    height: 100%;
+                }
+
+                .headerbar-profile-btn {
+                    background: transparent;
+                    padding: 6px;
+                    border: 0;
+                    cursor: pointer;
+                }
+                .headerbar-profile-btn:focus {
+                    outline: 2px solid white;
+                    outline-offset: -2px;
+                }
+                .headerbar-profile-btn:focus:not(:focus-visible) {
+                    outline: none;
+                }
+                .headerbar-profile-btn:hover {
+                    background: #1a557f;
+                }
+                .headerbar-profile-btn:active {
+                    background: #104067;
+                }
+            `)));
+};
+Profile.propTypes = {
+    name: PropTypes.string.isRequired,
+    avatarId: PropTypes.string,
+    email: PropTypes.string,
+    helpUrl: PropTypes.string,
+};
+export default Profile;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/modules/header-bar/utils/title.mjs

@@ -0,0 +1,22 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+export const Title = (params) => {
+    const { app, instance } = params;
+    return (React.createElement("div", { className: "headerbar-title", "data-test": "headerbar-title" },
+        app ? `${instance} - ${app}` : `${instance}`,
+        React.createElement("style", { jsx: true }, `
+        .headerbar-title {
+          overflow: hidden;
+          text-overflow: ellipsis;
+          font-size: 14px;
+          font-weight: 500;
+          letter-spacing: 0.01em;
+          white-space: nowrap;
+        }
+      `)));
+};
+Title.propTypes = {
+    app: PropTypes.string,
+    instance: PropTypes.string,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGl0bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9uZy1kaGlzMi11aS9zcmMvbGliL21vZHVsZXMvaGVhZGVyLWJhci91dGlscy90aXRsZS50c3giXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxTQUFTLE1BQU0sWUFBWSxDQUFDO0FBQ25DLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQVExQixNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsQ0FBQyxNQUFXLEVBQUUsRUFBRTtJQUNuQyxNQUFNLEVBQUUsR0FBRyxFQUFFLFFBQVEsRUFBRSxHQUFHLE1BQU0sQ0FBQztJQUNqQyxPQUFPLENBQ0wsNkJBQUssU0FBUyxFQUFDLGlCQUFpQixlQUFXLGlCQUFpQjtRQUN6RCxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsUUFBUSxNQUFNLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQyxHQUFHLFFBQVEsRUFBRTtRQUU3QywrQkFBTyxHQUFHLFVBQUU7Ozs7Ozs7OztPQVNYLENBQVMsQ0FDTixDQUNQLENBQUM7QUFDSixDQUFDLENBQUM7QUFDRixLQUFLLENBQUMsU0FBUyxHQUFHO0lBQ2hCLEdBQUcsRUFBRSxTQUFTLENBQUMsTUFBTTtJQUNyQixRQUFRLEVBQUUsU0FBUyxDQUFDLE1BQU07Q0FDM0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBQcm9wVHlwZXMgZnJvbSAncHJvcC10eXBlcyc7XG5pbXBvcnQgUmVhY3QgZnJvbSAncmVhY3QnO1xuZGVjbGFyZSBtb2R1bGUgJ3JlYWN0JyB7XG4gIGludGVyZmFjZSBTdHlsZUhUTUxBdHRyaWJ1dGVzPFQ+IGV4dGVuZHMgUmVhY3QuSFRNTEF0dHJpYnV0ZXM8VD4ge1xuICAgIGpzeD86IGJvb2xlYW47XG4gICAgZ2xvYmFsPzogYm9vbGVhbjtcbiAgfVxufVxuXG5leHBvcnQgY29uc3QgVGl0bGUgPSAocGFyYW1zOiBhbnkpID0+IHtcbiAgY29uc3QgeyBhcHAsIGluc3RhbmNlIH0gPSBwYXJhbXM7XG4gIHJldHVybiAoXG4gICAgPGRpdiBjbGFzc05hbWU9XCJoZWFkZXJiYXItdGl0bGVcIiBkYXRhLXRlc3Q9XCJoZWFkZXJiYXItdGl0bGVcIj5cbiAgICAgIHthcHAgPyBgJHtpbnN0YW5jZX0gLSAke2FwcH1gIDogYCR7aW5zdGFuY2V9YH1cblxuICAgICAgPHN0eWxlIGpzeD57YFxuICAgICAgICAuaGVhZGVyYmFyLXRpdGxlIHtcbiAgICAgICAgICBvdmVyZmxvdzogaGlkZGVuO1xuICAgICAgICAgIHRleHQtb3ZlcmZsb3c6IGVsbGlwc2lzO1xuICAgICAgICAgIGZvbnQtc2l6ZTogMTRweDtcbiAgICAgICAgICBmb250LXdlaWdodDogNTAwO1xuICAgICAgICAgIGxldHRlci1zcGFjaW5nOiAwLjAxZW07XG4gICAgICAgICAgd2hpdGUtc3BhY2U6IG5vd3JhcDtcbiAgICAgICAgfVxuICAgICAgYH08L3N0eWxlPlxuICAgIDwvZGl2PlxuICApO1xufTtcblRpdGxlLnByb3BUeXBlcyA9IHtcbiAgYXBwOiBQcm9wVHlwZXMuc3RyaW5nLFxuICBpbnN0YW5jZTogUHJvcFR5cGVzLnN0cmluZyxcbn07XG4iXX0=

package/esm2022/lib/ng-dhis2-ui.module.mjs

@@ -0,0 +1,15 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+export class NgDhis2UiModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgDhis2UiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NgDhis2UiModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgDhis2UiModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgDhis2UiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctZGhpczItdWkubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vbmctZGhpczItdWkvc3JjL2xpYi9uZy1kaGlzMi11aS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7O0FBSy9DLE1BQU0sT0FBTyxlQUFlOytHQUFmLGVBQWU7Z0hBQWYsZUFBZSxZQUZoQixZQUFZO2dIQUVYLGVBQWUsWUFGaEIsWUFBWTs7NEZBRVgsZUFBZTtrQkFIM0IsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7aUJBQ3hCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxufSlcbmV4cG9ydCBjbGFzcyBOZ0RoaXMyVWlNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/shared/components/index.mjs

@@ -0,0 +1,7 @@
+// Copyright 2023 UDSM DHIS2 Lab. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+import { ReactWrapperComponent } from './react-component-wrapper/react-wrapper.component';
+export const sharedComponents = [];
+export { ReactWrapperComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9uZy1kaGlzMi11aS9zcmMvbGliL3NoYXJlZC9jb21wb25lbnRzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHNEQUFzRDtBQUN0RCxxREFBcUQ7QUFDckQsaURBQWlEO0FBQ2pELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1EQUFtRCxDQUFDO0FBRTFGLE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFVLEVBQUUsQ0FBQztBQUUxQyxPQUFPLEVBQUUscUJBQXFCLEVBQUUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDIzIFVEU00gREhJUzIgTGFiLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuLy8gVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYSBCU0Qtc3R5bGVcbi8vIGxpY2Vuc2UgdGhhdCBjYW4gYmUgZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZS5cbmltcG9ydCB7IFJlYWN0V3JhcHBlckNvbXBvbmVudCB9IGZyb20gJy4vcmVhY3QtY29tcG9uZW50LXdyYXBwZXIvcmVhY3Qtd3JhcHBlci5jb21wb25lbnQnO1xuXG5leHBvcnQgY29uc3Qgc2hhcmVkQ29tcG9uZW50czogYW55W10gPSBbXTtcblxuZXhwb3J0IHsgUmVhY3RXcmFwcGVyQ29tcG9uZW50IH07XG4iXX0=

package/esm2022/lib/shared/components/react-component-wrapper/react-wrapper.component.mjs

@@ -0,0 +1,53 @@
+import { ContentChild, Directive, ElementRef, Input, } from '@angular/core';
+import parse from 'html-react-parser';
+import * as React from 'react';
+import * as ReactDOM from 'react-dom/client';
+import * as i0 from "@angular/core";
+window.React = React;
+export class ReactWrapperComponent {
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+    }
+    ngAfterViewInit() {
+        if (!this.elementRef)
+            throw new Error('No element ref');
+        this.reactDomRoot = ReactDOM.createRoot(this.elementRef.nativeElement);
+        this.render();
+    }
+    ngOnChanges() {
+        if (this.elementRef)
+            this.render();
+    }
+    ngOnDestroy() {
+        this.reactDomRoot?.unmount();
+    }
+    render() {
+        if (!this.component)
+            throw new Error('React component must be supplied');
+        if (!this.reactDomRoot)
+            return;
+        const jsxContent = this.content?.nativeElement?.outerHTML
+            ? parse(this.content?.nativeElement?.outerHTML)
+            : undefined;
+        this.reactDomRoot.render(React.createElement(this.component, { ...this.props },
+            " ",
+            jsxContent || '',
+            " "));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ReactWrapperComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: ReactWrapperComponent, selector: "ng-dhis2-ui-wrapper", inputs: { props: "props", component: "component" }, queries: [{ propertyName: "content", first: true, predicate: ["ngDhis2UiContent"], descendants: true }], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: ReactWrapperComponent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-dhis2-ui-wrapper',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { props: [{
+                type: Input
+            }], component: [{
+                type: Input
+            }], content: [{
+                type: ContentChild,
+                args: ['ngDhis2UiContent']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/shared/shared.module.mjs

@@ -0,0 +1,18 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { sharedComponents } from './components';
+import * as i0 from "@angular/core";
+export class SharedDhis2UiModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedDhis2UiModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: SharedDhis2UiModule, imports: [CommonModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedDhis2UiModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: SharedDhis2UiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [...sharedComponents],
+                    exports: [...sharedComponents],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2hhcmVkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL25nLWRoaXMyLXVpL3NyYy9saWIvc2hhcmVkL3NoYXJlZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sY0FBYyxDQUFDOztBQU9oRCxNQUFNLE9BQU8sbUJBQW1COytHQUFuQixtQkFBbUI7Z0hBQW5CLG1CQUFtQixZQUpwQixZQUFZO2dIQUlYLG1CQUFtQixZQUpwQixZQUFZOzs0RkFJWCxtQkFBbUI7a0JBTC9CLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixZQUFZLEVBQUUsQ0FBQyxHQUFHLGdCQUFnQixDQUFDO29CQUNuQyxPQUFPLEVBQUUsQ0FBQyxHQUFHLGdCQUFnQixDQUFDO2lCQUMvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgc2hhcmVkQ29tcG9uZW50cyB9IGZyb20gJy4vY29tcG9uZW50cyc7XG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICBkZWNsYXJhdGlvbnM6IFsuLi5zaGFyZWRDb21wb25lbnRzXSxcbiAgZXhwb3J0czogWy4uLnNoYXJlZENvbXBvbmVudHNdLFxufSlcbmV4cG9ydCBjbGFzcyBTaGFyZWREaGlzMlVpTW9kdWxlIHt9XG4iXX0=