@dhis2-ui/organisation-unit-tree 10.16.2 → 10.16.3-alpha.1

package/src/features/tree_api/index.js

@@ -0,0 +1,121 @@
+import { Given, When, Then } from '@badeball/cypress-cucumber-preprocessor'
+
+const expectStubPayloadToEqual = (stub, prop, expected) => {
+    const calls = stub.getCalls()
+    const { args } = calls[calls.length - 1]
+    const [payload] = args
+    expect(payload[prop]).to.eql(expected)
+}
+
+Given('an OrganisationUnitTree is rendered', () => {
+    cy.visitStory('OrganisationUnitTree', 'Events')
+    cy.getOrgUnitByLabel('Org Unit 1').shouldBeDoneLoading()
+})
+
+Given('a node has been selected', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').toggleOrgUnitNodeSelection(true)
+})
+
+Given('a node with children is rendered', () => {
+    cy.visitStory('OrganisationUnitTree', 'Events')
+})
+
+Given('the node has been expanded', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').openOrgUnitNode()
+})
+
+Given("the children haven't been loaded yet", () => {
+    cy.window().should((win) => {
+        expect(win.onExpand).not.to.be.called
+    })
+})
+
+When('a node gets selected', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').toggleOrgUnitNodeSelection(true)
+})
+
+When('a node gets deselected', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').toggleOrgUnitNodeSelection(false)
+})
+
+When('the node is expanded', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').openOrgUnitNode()
+})
+
+When('a node is collapsed', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').closeOrgUnitNode()
+})
+
+When('the children have been loaded', () => {
+    cy.getOrgUnitByLabel('Org Unit 1').toggleOrgUnitNode(true)
+})
+
+Then('the onChange callback gets called', () => {
+    cy.window().should((win) => {
+        expect(win.onChange).to.be.called
+    })
+})
+
+Then('the payload includes the path of the selected node', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onChange, 'path', '/A0000000000')
+    })
+})
+
+Then('the payload includes checked which is set to "true"', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onChange, 'checked', true)
+    })
+})
+
+Then('the payload includes all selected nodes', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onChange, 'selected', ['/A0000000000'])
+    })
+})
+
+Then('the payload includes checked which is set to "false"', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onChange, 'checked', false)
+    })
+})
+
+Then('the onExpand callback gets called', () => {
+    cy.window().should((win) => {
+        expect(win.onExpand).to.be.called
+    })
+})
+
+Then('the payload includes the path of the expanded node', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onExpand, 'path', '/A0000000000')
+    })
+})
+
+Then('the onCollapse callback gets called', () => {
+    cy.window().should((win) => {
+        expect(win.onCollapse).to.be.called
+    })
+})
+
+Then('the payload includes the path of the collapsed node', () => {
+    cy.window().should((win) => {
+        expectStubPayloadToEqual(win.onCollapse, 'path', '/A0000000000')
+    })
+})
+
+Then('the onChildrenLoaded callback gets called', () => {
+    cy.window().should((win) => {
+        expect(win.onChildrenLoaded).to.be.called
+    })
+})
+
+Then("the payload contains the loaded children's data", () => {
+    cy.window().should((win) => {
+        const calls = win.onChildrenLoaded.getCalls()
+        expect(calls).to.have.length(1)
+
+        const [{ args }] = calls
+        expect(args[0].id).to.equal('A0000000000')
+    })
+})

package/src/features/tree_api.feature

@@ -0,0 +1,37 @@
+Feature: The OrganisationUnitTree offers props for its events
+
+    Scenario: The user selects a node
+        Given an OrganisationUnitTree is rendered
+        When a node gets selected
+        Then the onChange callback gets called
+        And the payload includes the path of the selected node
+        And the payload includes checked which is set to "true"
+        And the payload includes all selected nodes
+
+    Scenario: The user deselects a node
+        Given an OrganisationUnitTree is rendered
+        And a node has been selected
+        When a node gets deselected
+        Then the onChange callback gets called
+        And the payload includes the path of the selected node
+        And the payload includes checked which is set to "false"
+
+    Scenario: The user expands a node with children
+        Given a node with children is rendered
+        When the node is expanded
+        Then the onExpand callback gets called
+        And the payload includes the path of the expanded node
+
+    Scenario: The user collapses a node with children
+        Given a node with children is rendered
+        And the node has been expanded
+        When a node is collapsed
+        Then the onCollapse callback gets called
+        And the payload includes the path of the collapsed node
+
+    Scenario: Children of a node are done being loaded
+        Given a node with children is rendered
+        But the children haven't been loaded yet
+        When the children have been loaded
+        Then the onChildrenLoaded callback gets called
+        And the payload contains the loaded children's data

package/src/get-all-expanded-paths/get-all-expanded-paths.js

@@ -0,0 +1,32 @@
+/**
+ * @template T
+ * @param {Array.<T>} arr
+ * @returns {Array.<T>}
+ */
+const removeDuplicates = (arr) => Array.from(new Set(arr))
+
+/**
+ * @param {string} path
+ * @returns {string[]}
+ */
+const extractAllPathsFromPath = (path) => {
+    // remove leading slash and split by path delimiter/slashes
+    const segments = path.replace(/^\//, '').split('/')
+
+    const withSubPaths = segments.map((segment, index) => {
+        // take all segments from 0 to index and join them with the delimiter
+        return `/${segments.slice(0, index + 1).join('/')}`
+    })
+
+    return removeDuplicates(withSubPaths)
+}
+
+/**
+ * @param {string[]} initiallyExpanded
+ * @returns {string[]}
+ */
+export const getAllExpandedPaths = (initiallyExpanded) =>
+    initiallyExpanded.reduce((all, curPath) => {
+        const allPathsInCurPath = extractAllPathsFromPath(curPath)
+        return [...all, ...allPathsInCurPath]
+    }, [])

package/src/get-all-expanded-paths/get-all-expanded-paths.test.js

@@ -0,0 +1,22 @@
+import { getAllExpandedPaths } from './get-all-expanded-paths.js'
+
+describe('OrganisationUnitTree - getAllExpandedPaths', () => {
+    const initiallyExpanded = ['/foo/bar/baz', '/foobar/barbaz/bazfoo']
+
+    it('should include all initiallyExpanded paths in the returned expanded array', () => {
+        const actual = getAllExpandedPaths(initiallyExpanded)
+        const expected = expect.arrayContaining(initiallyExpanded)
+        expect(actual).toEqual(expected)
+    })
+
+    it('should include all sub paths of the paths in initiallyExpanded in the returned exanded array', () => {
+        const actual = getAllExpandedPaths(initiallyExpanded)
+        const expected = expect.arrayContaining([
+            '/foo',
+            '/foo/bar',
+            '/foobar',
+            '/foobar/barbaz',
+        ])
+        expect(actual).toEqual(expected)
+    })
+})

package/src/get-all-expanded-paths/index.js

@@ -0,0 +1 @@
+export { getAllExpandedPaths } from './get-all-expanded-paths.js'

package/src/helpers/index.js

@@ -0,0 +1,3 @@
+export { isPathIncluded } from './is-path-included.js'
+export { leftTrimToRootId } from './left-trim-to-root-id.js'
+export { sortNodeChildrenAlphabetically } from './sort-node-children-alphabetically.js'

package/src/helpers/is-path-included.js

@@ -0,0 +1,15 @@
+/**
+ * @param {string[]} includedPaths
+ * @param {string} path
+ * @returns {bool}
+ */
+export const isPathIncluded = (includedPaths, path) => {
+    const isIncluded = includedPaths.some((includedPath) => {
+        if (path === includedPath) {
+            return true
+        }
+        return includedPath.startsWith(`${path}/`)
+    })
+
+    return isIncluded
+}

package/src/helpers/left-trim-to-root-id.js

@@ -0,0 +1,3 @@
+export const leftTrimToRootId = (path, rootId) => {
+    return path.replace(new RegExp(`^.*(/${rootId})`), '$1')
+}

package/src/helpers/sort-node-children-alphabetically.js

@@ -0,0 +1,5 @@
+// sort mutates the original
+export const sortNodeChildrenAlphabetically = (children) =>
+    [...children].sort((left, right) =>
+        left.displayName.localeCompare(right.displayName)
+    )

package/src/index.js

@@ -0,0 +1,6 @@
+export {
+    OrganisationUnitTree,
+    OrganisationUnitTreeRootError,
+    OrganisationUnitTreeRootLoading,
+} from './organisation-unit-tree/index.js'
+export { getAllExpandedPaths as getAllExpandedOrgUnitPaths } from './get-all-expanded-paths/index.js'

package/src/locales/ar/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "",
+    "Could not load children": "تعذر تحميل الأبناء",
+    "Error: {{ ERRORMESSAGE }}": "خطأ: {{ ERRORMESSAGE }}"
+}

package/src/locales/cs/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Filtru neodpovídají žádné podřízené",
+    "Could not load children": "Nelze načíst podřazené",
+    "Error: {{ ERRORMESSAGE }}": "Chyba: {{ ERRORMESSAGE }}"
+}

package/src/locales/en/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "No children match filter",
+    "Could not load children": "Could not load children",
+    "Error: {{ ERRORMESSAGE }}": "Error: {{ ERRORMESSAGE }}"
+}

package/src/locales/es/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Sin filtros de coincidencia en los elementos inferiores",
+    "Could not load children": "No se pudo cargar los elementos inferiores",
+    "Error: {{ ERRORMESSAGE }}": "Error: {{ ERRORMESSAGE }}"
+}

package/src/locales/es_419/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Ningún descendiente coincide con el filtro",
+    "Could not load children": "No se han podido cargar los descendientes",
+    "Error: {{ ERRORMESSAGE }}": "Error: {{ ERRORMESSAGE }}"
+}

package/src/locales/fr/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Aucun enfant ne correspond au filtre",
+    "Could not load children": "Impossible de charger les enfants",
+    "Error: {{ ERRORMESSAGE }}": "Erreur : {{ ERRORMESSAGE }}"
+}

package/src/locales/index.js

@@ -0,0 +1,50 @@
+//------------------------------------------------------------------------------
+// <auto-generated>
+// This code was generated by d2-i18n-generate.
+//
+// Changes to this file may cause incorrect behavior and will be lost if
+// the code is regenerated.
+// </auto-generated>
+//------------------------------------------------------------------------------
+import i18n from '@dhis2/d2-i18n'
+
+import arTranslations from './ar/translations.json'
+import csTranslations from './cs/translations.json'
+import enTranslations from './en/translations.json'
+import esTranslations from './es/translations.json'
+import es_419Translations from './es_419/translations.json'
+import frTranslations from './fr/translations.json'
+import loTranslations from './lo/translations.json'
+import nbTranslations from './nb/translations.json'
+import nlTranslations from './nl/translations.json'
+import ptTranslations from './pt/translations.json'
+import ruTranslations from './ru/translations.json'
+import ukTranslations from './uk/translations.json'
+import uz_LatnTranslations from './uz_Latn/translations.json'
+import uz_UZ_CyrlTranslations from './uz_UZ_Cyrl/translations.json'
+import uz_UZ_LatnTranslations from './uz_UZ_Latn/translations.json'
+import viTranslations from './vi/translations.json'
+import zhTranslations from './zh/translations.json'
+import zh_CNTranslations from './zh_CN/translations.json'
+
+const namespace = 'default'
+i18n.addResources('ar', namespace, arTranslations)
+i18n.addResources('cs', namespace, csTranslations)
+i18n.addResources('en', namespace, enTranslations)
+i18n.addResources('es', namespace, esTranslations)
+i18n.addResources('es_419', namespace, es_419Translations)
+i18n.addResources('fr', namespace, frTranslations)
+i18n.addResources('lo', namespace, loTranslations)
+i18n.addResources('nb', namespace, nbTranslations)
+i18n.addResources('nl', namespace, nlTranslations)
+i18n.addResources('pt', namespace, ptTranslations)
+i18n.addResources('ru', namespace, ruTranslations)
+i18n.addResources('uk', namespace, ukTranslations)
+i18n.addResources('uz_Latn', namespace, uz_LatnTranslations)
+i18n.addResources('uz_UZ_Cyrl', namespace, uz_UZ_CyrlTranslations)
+i18n.addResources('uz_UZ_Latn', namespace, uz_UZ_LatnTranslations)
+i18n.addResources('vi', namespace, viTranslations)
+i18n.addResources('zh', namespace, zhTranslations)
+i18n.addResources('zh_CN', namespace, zh_CNTranslations)
+
+export default i18n

package/src/locales/lo/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "ບໍ່ພົບເດັກນ້ອຍທີ່ກົງກັບຕົວກອງ",
+    "Could not load children": "ບໍ່ສາມາດໂຫຼດເດັກນ້ອຍໄດ້",
+    "Error: {{ ERRORMESSAGE }}": "ຂໍ້ຜິດພາດ {{ ERRORMESSAGE }}"
+}

package/src/locales/nb/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Ingen underenheter matcher filter",
+    "Could not load children": "Kunne ikke laste underordnede enheter",
+    "Error: {{ ERRORMESSAGE }}": "Feil: {{ ERRORMESSAGE }}"
+}

package/src/locales/nl/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Er komen geen kinderen overeen met het filter",
+    "Could not load children": "Kan kinderen niet laden",
+    "Error: {{ ERRORMESSAGE }}": "Fout: {{ ERRORMESSAGE }}"
+}

package/src/locales/pt/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Nenhum filho corresponde ao filtro",
+    "Could not load children": "Não foi possível carregar os filhos",
+    "Error: {{ ERRORMESSAGE }}": "Erro: {{ ERRORMESSAGE }}"
+}

package/src/locales/ru/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Нет дочерних единиц, соответствующих фильтру",
+    "Could not load children": "¨Не удалось загрузить дочерние единицы",
+    "Error: {{ ERRORMESSAGE }}": "Ошибка: {{ ERRORMESSAGE }}"
+}

package/src/locales/uk/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Немає дочірніх об'єктів, які відповідають фільтру",
+    "Could not load children": "Не вдалося завантажити дочірні об'єкти",
+    "Error: {{ ERRORMESSAGE }}": "Помилка: {{ ERRORMESSAGE }}"
+}

package/src/locales/uz_Latn/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "",
+    "Could not load children": "Bolalar yuklanmadi",
+    "Error: {{ ERRORMESSAGE }}": ""
+}

package/src/locales/uz_UZ_Cyrl/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Фильтрга мос бўлган авлод мавжуд эмас",
+    "Could not load children": "Болалар юкланмади",
+    "Error: {{ ERRORMESSAGE }}": "Хатолик: {{ ERRORMESSAGE }}"
+}

package/src/locales/uz_UZ_Latn/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "",
+    "Could not load children": "Bolalar yuklanmadi",
+    "Error: {{ ERRORMESSAGE }}": ""
+}

package/src/locales/vi/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "Không có đơn vị con phù hợp với bộ lọc",
+    "Could not load children": "Không thể tải đơn vị con",
+    "Error: {{ ERRORMESSAGE }}": "Lỗi: {{ ERRORMESSAGE }}"
+}

package/src/locales/zh/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "没有下属匹配过滤器",
+    "Could not load children": "无法加载下属",
+    "Error: {{ ERRORMESSAGE }}": "错误：{{ ERRORMESSAGE }}"
+}

package/src/locales/zh_CN/translations.json

@@ -0,0 +1,5 @@
+{
+    "No children match filter": "",
+    "Could not load children": "无法加载下属",
+    "Error: {{ ERRORMESSAGE }}": ""
+}

package/src/organisation-unit-node/compute-child-nodes.js

@@ -0,0 +1,27 @@
+import { isPathIncluded } from '../helpers/index.js'
+
+/**
+ * Returns all the childrenIds that should be rendered.
+ * An id will be included if it's parent's path + the id is inside
+ * the "filter" or the parent's path + id is a substring
+ * of the paths in "filter" (then it's a parent path of
+ * the units that should be included itself)
+ *
+ * @param {Object} node
+ * @param {Object[]} node.children
+ * @param {string[]} includedPaths
+ * @returns {string[]}
+ */
+export const computeChildNodes = (node, filter) => {
+    if (!node.children) {
+        return []
+    }
+
+    if (!filter.length) {
+        return node.children
+    }
+
+    return node.children.filter((child) => {
+        return isPathIncluded(filter, `${node.path}/${child.id}`)
+    })
+}

package/src/organisation-unit-node/compute-child-nodes.test.js

@@ -0,0 +1,85 @@
+import { computeChildNodes } from './compute-child-nodes.js'
+
+describe('computeChildNodes', () => {
+    let node = { path: 'foo/bar' }
+    const defaultChildren = [
+        { id: 'foobar' },
+        { id: 'barbaz' },
+        { id: 'foobarbaz' },
+    ]
+    const defaultChildrenIds = defaultChildren
+    const irrelevantPaths = ['irrelevant/path']
+    const pathsToIncludeWithMatchingAncestors = [
+        'foo/bar/foobar/barbaz',
+        'foo/bar/barbaz/bazbazfoo',
+    ]
+    const pathsToIncludeWithMatchingChildren = ['foo/bar/foobar']
+    const pathsToIncludeWithMatchingParents = ['foo/bar']
+
+    beforeEach(() => {
+        node = { path: 'foo/bar' }
+    })
+
+    it('should return all children when filter is empty', () => {
+        node.children = defaultChildren
+        const filter = []
+        const actual = computeChildNodes(node, filter)
+        const expected = defaultChildrenIds
+
+        expect(actual).toEqual(expected)
+    })
+
+    it("should return an empty array when the node has children but neither the children's or the parent path are in filter", () => {
+        node.children = defaultChildren
+        const filter = irrelevantPaths
+        const actual = computeChildNodes(node, filter)
+        const expected = []
+
+        expect(actual).toEqual(expected)
+    })
+
+    it('should return an empty array when filter contains none of the child paths but a parent path', () => {
+        node.children = defaultChildren
+        const filter = pathsToIncludeWithMatchingParents
+        const actual = computeChildNodes(node, filter)
+        const expected = []
+
+        expect(actual).toEqual(expected)
+    })
+
+    it('should return some the children ids when filter contains none of the child paths but some ancestor paths', () => {
+        node.children = defaultChildren
+        const filter = pathsToIncludeWithMatchingAncestors
+        const actual = computeChildNodes(node, filter)
+        const expected = [{ id: 'foobar' }, { id: 'barbaz' }]
+
+        expect(actual).toEqual(expected)
+    })
+
+    it('should return one of the children ids when filter contains one of the child paths but no parent path', () => {
+        node.children = defaultChildren
+        const filter = pathsToIncludeWithMatchingChildren
+        const actual = computeChildNodes(node, filter)
+        const expected = [{ id: 'foobar' }]
+
+        expect(actual).toEqual(expected)
+    })
+
+    it('should return an empty array when the node has no children but filter is not empty', () => {
+        node.children = []
+        const filter = pathsToIncludeWithMatchingParents
+        const actual = computeChildNodes(node, filter)
+        const expected = []
+
+        expect(actual).toEqual(expected)
+    })
+
+    it('should return an empty array when the node has no children and filter is empty', () => {
+        node.children = []
+        const filter = []
+        const actual = computeChildNodes(node, filter)
+        const expected = []
+
+        expect(actual).toEqual(expected)
+    })
+})

package/src/organisation-unit-node/error-message.js

@@ -0,0 +1,23 @@
+import { colors, spacers, theme } from '@dhis2/ui-constants'
+import PropTypes from 'prop-types'
+import React from 'react'
+
+export const ErrorMessage = ({ children, dataTest }) => (
+    <span data-test={`${dataTest}-error`}>
+        {children}
+
+        <style jsx>{`
+            span {
+                font-size: 14px;
+                color: ${colors.grey800};
+                margin: ${spacers.dp4};
+                color: ${theme.error};
+            }
+        `}</style>
+    </span>
+)
+
+ErrorMessage.propTypes = {
+    children: PropTypes.any.isRequired,
+    dataTest: PropTypes.string.isRequired,
+}

package/src/organisation-unit-node/has-descendant-selected-paths.js

@@ -0,0 +1,15 @@
+/**
+ * Checks wether there are descendants of a path in the
+ * array of selected paths
+ *
+ * @param {string} path
+ * @param {string[]} selected
+ * @returns {bool}
+ */
+export const hasDescendantSelectedPaths = (path, selected) => {
+    return selected.some((selectedPath) => {
+        const isNotPath = !selectedPath.match(new RegExp(`${path}$`))
+        const isSubPath = selectedPath.match(new RegExp(path))
+        return isNotPath && isSubPath
+    })
+}

package/src/organisation-unit-node/has-descendant-selected-paths.test.js

@@ -0,0 +1,30 @@
+import { hasDescendantSelectedPaths } from './has-descendant-selected-paths.js'
+
+describe('hasDescendantSelectedPaths', () => {
+    it('should return true when the path is a parent path of one of the selected paths', () => {
+        const path = '/foo/bar'
+        const selected = ['/foo/bar/baz', '/foobar/barbaz/']
+        const expected = true
+        const actual = hasDescendantSelectedPaths(path, selected)
+
+        expect(actual).toBe(expected)
+    })
+
+    it('should return false when the paths is not a parent path but an exact match with one of the selected paths', () => {
+        const path = '/foo/bar/baz'
+        const selected = ['/foo/bar/baz', '/foobar/barbaz/']
+        const expected = false
+        const actual = hasDescendantSelectedPaths(path, selected)
+
+        expect(actual).toBe(expected)
+    })
+
+    it('should return false when the paths is neither a parent path nor an exact match with one of the selected paths', () => {
+        const path = '/foobarbaz/boofarzab'
+        const selected = ['/foo/bar/baz', '/foobar/barbaz/']
+        const expected = false
+        const actual = hasDescendantSelectedPaths(path, selected)
+
+        expect(actual).toBe(expected)
+    })
+})

package/src/organisation-unit-node/index.js

@@ -0,0 +1 @@
+export { OrganisationUnitNode } from './organisation-unit-node.js'

package/src/organisation-unit-node/label/disabled-selection-label.js

@@ -0,0 +1,26 @@
+import PropTypes from 'prop-types'
+import React from 'react'
+import { SingleSelectionLabel } from './single-selection-label.js'
+
+/**
+ * @param {Object} props
+ * @param {string} props.label
+ * @param {Function} props.onToggleOpen
+ * @param {bool} [props.loading]
+ * @returns {React.Component}
+ */
+export const DisabledSelectionLabel = ({ children, loading, onToggleOpen }) => (
+    <SingleSelectionLabel
+        checked={false}
+        loading={loading}
+        onChange={onToggleOpen}
+    >
+        {children}
+    </SingleSelectionLabel>
+)
+
+DisabledSelectionLabel.propTypes = {
+    children: PropTypes.any.isRequired,
+    onToggleOpen: PropTypes.func.isRequired,
+    loading: PropTypes.bool,
+}