diff --git a/docusaurus.config.ts b/docusaurus.config.ts index 90298169e6dbe..29478acafd657 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -86,7 +86,7 @@ const config: Config = { { name: 'twitter:image', content: 'https://developer.sailpoint.com/img/SailPoint-Logo-OG.png' }, // Content Security Policy - { 'http-equiv': 'Content-Security-Policy', content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" }, + { 'http-equiv': 'Content-Security-Policy', content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net https://fonts.googleapis.com; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com https://fonts.gstatic.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" }, ], algolia: { appId: 'TB01H1DFAM', @@ -159,6 +159,7 @@ const config: Config = { AUTH_PASSWORD: process.env.AUTH_PASSWORD || '', ENDPOINT_OVERRIDE: process.env.ENDPOINT_OVERRIDE || '', SAMPLE_TABLE: process.env.SAMPLE_TABLE || '', + SECRET_MESSAGE: process.env.SECRET_MESSAGE || '', CMS_APP_API_ENDPOINT: process.env.NODE_ENV === 'development' ? 'http://localhost:3000/' @@ -166,4 +167,4 @@ const config: Config = { }, }; -export default config; +export default config; \ No newline at end of file diff --git a/navbar.ts b/navbar.ts index ae0c094a36995..795922cb1bdef 100644 --- a/navbar.ts +++ b/navbar.ts @@ -34,6 +34,7 @@ const navbarConfig = { { label: 'CLI', to: '/docs/tools/cli' }, { label: 'Escaping Tool Formatter', to: '/tools/escaping-tool-formatter' }, { label: 'JSON Path Evaluator', to: '/tools/json-path-evaluator' }, + { label: 'XPath Evaluator', to: '/tools/xpath-evaluator' }, { label: 'Rule Development Kit', to: '/docs/tools/rule-development-kit' }, { label: 'UI Development Kit', to: '/docs/tools/ui-development-kit' }, { label: 'Velocity PlayGround', to: '/tools/velocity-playground' }, diff --git a/package-lock.json b/package-lock.json index a9c8af701c522..a08365cd7c827 100644 --- a/package-lock.json +++ b/package-lock.json @@ -32,6 +32,7 @@ "@mui/material": "^6.1.6", "@reduxjs/toolkit": "^2.11.2", "@typeform/embed-react": "^1.21.0", + "@xmldom/xmldom": "^0.9.10", "ace-builds": "^1.36.4", "autoprefixer": "^10.4.13", "canvas-confetti": "^1.9.3", @@ -50,7 +51,8 @@ "react-markdown": "^8.0.7", "react-spinners": "^0.13.8", "react-tabs": "^4.3.0", - "velocityjs": "^2.1.5" + "velocityjs": "^2.1.5", + "xpath": "^0.0.34" }, "devDependencies": { "@docusaurus/core": "3.9.2", @@ -7631,6 +7633,15 @@ "@xtuc/long": "4.2.2" } }, + "node_modules/@xmldom/xmldom": { + "version": "0.9.10", + "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.9.10.tgz", + "integrity": "sha512-A9gOqLdi6cV4ibazAjcQufGj0B1y/vDqYrcuP6d/6x8P27gRS8643Dj9o1dEKtB6O7fwxb2FgBmJS2mX7gpvdw==", + "license": "MIT", + "engines": { + "node": ">=14.6" + } + }, "node_modules/@xtuc/ieee754": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz", @@ -26151,6 +26162,15 @@ "node": ">= 16" } }, + "node_modules/xpath": { + "version": "0.0.34", + "resolved": "https://registry.npmjs.org/xpath/-/xpath-0.0.34.tgz", + "integrity": "sha512-FxF6+rkr1rNSQrhUNYrAFJpRXNzlDoMxeXN5qI84939ylEv3qqPFKa85Oxr6tDaJKqwW6KKyo2v26TSv3k6LeA==", + "license": "MIT", + "engines": { + "node": ">=0.6.0" + } + }, "node_modules/y18n": { "version": "5.0.8", "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", diff --git a/package.json b/package.json index 1888e9f63574d..f370d134a66c9 100644 --- a/package.json +++ b/package.json @@ -88,7 +88,9 @@ "react-markdown": "^8.0.7", "react-spinners": "^0.13.8", "react-tabs": "^4.3.0", - "velocityjs": "^2.1.5" + "velocityjs": "^2.1.5", + "@xmldom/xmldom": "^0.9.10", + "xpath": "^0.0.34" }, "overrides": { "mermaid": "10.9.3", diff --git a/src/components/xpath/ImplementationDropdown/index.tsx b/src/components/xpath/ImplementationDropdown/index.tsx new file mode 100644 index 0000000000000..234420693703b --- /dev/null +++ b/src/components/xpath/ImplementationDropdown/index.tsx @@ -0,0 +1,112 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import FormControl from '@mui/material/FormControl'; +import InputLabel from '@mui/material/InputLabel'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define prop types +interface ImplementationDropdownProps { + implementation: string; + onImplementationChange: (value: string) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const ImplementationDropdown: React.FC = ({ + implementation, + onImplementationChange, + onFocus, + onBlur, +}) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + const [expanded, setExpanded] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&.Mui-focused .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + MuiSelect: { + styleOverrides: { + icon: { + color: colorMode === 'dark' ? '#ffffff' : 'black', + }, + }, + }, + }, + }); + + const handleChange = (event: ChangeEvent<{ value: unknown }>) => { + onImplementationChange(event.target.value as string); + }; + + // Handle focus and blur state changes + const handleFocus = (event: FocusEvent) => { + setIsFocused(true); + if (onFocus) onFocus(event); + }; + + const handleBlur = (event: FocusEvent) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }; + + // Handle dropdown expanded state + const handleDropdownOpen = () => setExpanded(true); + const handleDropdownClose = () => setExpanded(false); + + return ( + + + + Implementation + + + + + + ); +}; + +export default ImplementationDropdown; diff --git a/src/components/xpath/InputTerminal/index.tsx b/src/components/xpath/InputTerminal/index.tsx new file mode 100644 index 0000000000000..ad567ec4c0567 --- /dev/null +++ b/src/components/xpath/InputTerminal/index.tsx @@ -0,0 +1,302 @@ +import React, {useEffect, useRef} from 'react'; +import AceEditor from 'react-ace'; +import 'ace-builds/src-noconflict/mode-xml'; +import 'ace-builds/src-noconflict/mode-json'; +import 'ace-builds/src-noconflict/mode-text'; +import 'ace-builds/src-noconflict/theme-github_dark'; +import 'ace-builds/src-noconflict/theme-github_light_default'; +import 'ace-builds/src-noconflict/ext-language_tools'; +import { useColorMode } from '@docusaurus/theme-common'; +import styles from '../../../pages/tools/xpath.module.css'; + +// Ensure ace is properly configured +declare const ace: any; +if (typeof ace !== 'undefined' && ace.config) { + ace.config.setModuleUrl( + 'ace/mode/xml_worker', + new URL( + 'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-xml.js' + ).toString(), + ); +} + +interface InputTerminalProps { + fontSize: string; + value: string; + onChange: (value: string) => void; + hasParseError?: boolean; + mode?: 'xml' | 'json' | 'text'; + title?: string; + onHoverValueChange?: (value: HoverValuePayload | null) => void; + onHoverLock?: (value: HoverValuePayload | null) => void; + lockedHoverValue?: HoverValuePayload | null; +} +export type HoverValuePayload = { + value: string; + nodeKind: 'attribute' | 'text'; + occurrenceIndex: number; + row: number; + startCol: number; + endCol: number; +}; + +const InputTerminal: React.FC = ({ + fontSize, + value, + onChange, + hasParseError = false, + mode = 'xml', + title = 'Inputs', + onHoverValueChange, + onHoverLock, + lockedHoverValue = null, +}) => { + const { colorMode } = useColorMode(); + const editorRef = useRef(null); + const lastHoveredPayloadRef = useRef(null); + const lastNotifiedPayloadRef = useRef(null); + const lockedMarkerIdRef = useRef(null); + + const terminalClass = hasParseError + ? styles.inputTerminalContainer + : styles.terminalContainerDefault; + + useEffect(() => { + if (mode !== 'xml' || !onHoverValueChange || !editorRef.current) { + return; + } + + const editor = editorRef.current.editor; + if (!editor) { + return; + } + + const escapeForRegex = (text: string): string => + text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); + + const countAttributeOccurrencesUntil = ( + fullText: string, + targetValue: string, + absoluteStart: number, + ): number => { + const escapedValue = escapeForRegex(targetValue); + const pattern = new RegExp(`=\\s*(['"])${escapedValue}\\1`, 'g'); + let count = 0; + let match: RegExpExecArray | null; + while ((match = pattern.exec(fullText)) !== null) { + const quoteOffset = match[0].search(/['"]/); + const valueStart = match.index + quoteOffset + 1; + if (valueStart > absoluteStart) { + break; + } + count += 1; + } + return Math.max(0, count - 1); + }; + + const countTextOccurrencesUntil = ( + fullText: string, + targetValue: string, + absoluteStart: number, + ): number => { + const pattern = />([^<]*) absoluteStart) { + break; + } + count += 1; + } + return Math.max(0, count - 1); + }; + + const extractHoveredValue = ( + line: string, + column: number, + ): {value: string; nodeKind: 'attribute' | 'text'; startCol: number} | null => { + if (!line) { + return null; + } + + const quoteChars = [`"`, `'`]; + for (const quote of quoteChars) { + const leftQuote = line.lastIndexOf(quote, column); + if (leftQuote >= 0) { + const rightQuote = line.indexOf(quote, leftQuote + 1); + if (rightQuote > leftQuote && column <= rightQuote) { + const quotedValue = line.slice(leftQuote + 1, rightQuote).trim(); + if (!quotedValue) { + return null; + } + return { + value: quotedValue, + nodeKind: 'attribute', + startCol: leftQuote + 1, + }; + } + } + } + + const leftTag = line.lastIndexOf('>', column); + const rightTag = line.indexOf('<', column); + if (leftTag >= 0 && rightTag > leftTag) { + const textValue = line.slice(leftTag + 1, rightTag).trim(); + if (!textValue) { + return null; + } + const originalSegment = line.slice(leftTag + 1, rightTag); + const trimmedOffset = originalSegment.indexOf(textValue); + return { + value: textValue, + nodeKind: 'text', + startCol: leftTag + 1 + Math.max(0, trimmedOffset), + }; + } + + return null; + }; + + const handleMouseMove = (event: MouseEvent) => { + const position = editor.renderer.screenToTextCoordinates( + event.clientX, + event.clientY, + ); + const line = editor.session.getLine(position.row); + const hoveredToken = extractHoveredValue(line, position.column); + if (!hoveredToken) { + lastHoveredPayloadRef.current = null; + if (lastNotifiedPayloadRef.current !== null) { + onHoverValueChange(null); + lastNotifiedPayloadRef.current = null; + } + return; + } + const absoluteStart = editor.session.doc.positionToIndex({ + row: position.row, + column: hoveredToken.startCol, + }); + const occurrenceIndex = + hoveredToken.nodeKind === 'attribute' + ? countAttributeOccurrencesUntil(value, hoveredToken.value, absoluteStart) + : countTextOccurrencesUntil(value, hoveredToken.value, absoluteStart); + const payload: HoverValuePayload = { + value: hoveredToken.value, + nodeKind: hoveredToken.nodeKind, + occurrenceIndex, + row: position.row, + startCol: hoveredToken.startCol, + endCol: hoveredToken.startCol + hoveredToken.value.length, + }; + lastHoveredPayloadRef.current = payload; + const lastNotified = lastNotifiedPayloadRef.current; + if ( + lastNotified && + lastNotified.value === payload.value && + lastNotified.nodeKind === payload.nodeKind && + lastNotified.occurrenceIndex === payload.occurrenceIndex + ) { + return; + } + onHoverValueChange(payload); + lastNotifiedPayloadRef.current = payload; + }; + + const handleMouseLeave = () => { + lastHoveredPayloadRef.current = null; + if (lastNotifiedPayloadRef.current !== null) { + onHoverValueChange(null); + lastNotifiedPayloadRef.current = null; + } + }; + + const handleMouseUp = () => { + if (!onHoverLock) { + return; + } + onHoverLock(lastHoveredPayloadRef.current); + }; + + editor.container.addEventListener('mousemove', handleMouseMove); + editor.container.addEventListener('mouseleave', handleMouseLeave); + editor.container.addEventListener('mouseup', handleMouseUp); + + return () => { + editor.container.removeEventListener('mousemove', handleMouseMove); + editor.container.removeEventListener('mouseleave', handleMouseLeave); + editor.container.removeEventListener('mouseup', handleMouseUp); + }; + }, [mode, onHoverLock, onHoverValueChange, value]); + + useEffect(() => { + if (mode !== 'xml' || !editorRef.current) { + return; + } + + const editor = editorRef.current.editor; + if (!editor) { + return; + } + + if (lockedMarkerIdRef.current !== null) { + editor.session.removeMarker(lockedMarkerIdRef.current); + lockedMarkerIdRef.current = null; + } + + if (!lockedHoverValue) { + return; + } + + const Range = ace.require('ace/range').Range; + lockedMarkerIdRef.current = editor.session.addMarker( + new Range( + lockedHoverValue.row, + lockedHoverValue.startCol, + lockedHoverValue.row, + lockedHoverValue.endCol, + ), + 'locked-hover-selection', + 'text', + false, + ); + + return () => { + if (lockedMarkerIdRef.current !== null) { + editor.session.removeMarker(lockedMarkerIdRef.current); + lockedMarkerIdRef.current = null; + } + }; + }, [lockedHoverValue, mode]); + + return ( +
+

{title}

+ { + editorRef.current = {editor}; + }} + className={terminalClass} + mode={mode} + theme={colorMode === 'dark' ? 'github_dark' : 'github_light_default'} + value={value} + onChange={onChange} + fontSize={`${fontSize}px`} + width="auto" + showPrintMargin={false} + editorProps={{ $blockScrolling: true }} + setOptions={{ + fontFamily: 'monospace', + }} + /> +
+ ); +}; + +export default InputTerminal; diff --git a/src/components/xpath/ResultTerminal/index.tsx b/src/components/xpath/ResultTerminal/index.tsx new file mode 100644 index 0000000000000..6ca944f2fe4f9 --- /dev/null +++ b/src/components/xpath/ResultTerminal/index.tsx @@ -0,0 +1,54 @@ +import React from 'react'; +import AceEditor from 'react-ace'; +import 'ace-builds/src-noconflict/mode-json'; +import 'ace-builds/src-noconflict/mode-text'; +import 'ace-builds/src-noconflict/theme-github_dark'; +import 'ace-builds/src-noconflict/theme-github_light_default'; +import 'ace-builds/src-noconflict/ext-language_tools'; +import { useColorMode } from '@docusaurus/theme-common'; +import styles from '../../../pages/tools/xpath.module.css'; + +// Ensure ace is properly configured +declare const ace: any; +if (typeof ace !== 'undefined' && ace.config) { + ace.config.setModuleUrl( + 'ace/mode/json_worker', + new URL( + 'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-json.js' + ).toString(), + ); +} + +// Props interface with optional `mode` +interface ResultTerminalProps { + result: string; + fontSize: string; + mode?: 'json' | 'text'; +} + +const ResultTerminal: React.FC = ({ result, fontSize, mode = 'json' }) => { + const { colorMode } = useColorMode(); + + return ( +
+

Evaluation results

+ + +
+ ); +}; + +export default ResultTerminal; diff --git a/src/components/xpath/TerminalFontSizeDropdown/index.tsx b/src/components/xpath/TerminalFontSizeDropdown/index.tsx new file mode 100644 index 0000000000000..3188f2c2d3593 --- /dev/null +++ b/src/components/xpath/TerminalFontSizeDropdown/index.tsx @@ -0,0 +1,114 @@ +import React, { useState, ChangeEvent, FocusEvent } from 'react'; +import FormControl from '@mui/material/FormControl'; +import InputLabel from '@mui/material/InputLabel'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; +import { useColorMode } from '@docusaurus/theme-common'; + +// Define props interface +interface TerminalFontSizeDropdownProps { + fontSize: string; + onFontSizeChange: (value: string) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const TerminalFontSizeDropdown: React.FC = ({ + fontSize, + onFontSizeChange, + onFocus, + onBlur, +}) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + const [expanded, setExpanded] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&.Mui-focused .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + MuiSelect: { + styleOverrides: { + icon: { + color: colorMode === 'dark' ? '#ffffff' : 'black', + }, + }, + }, + }, + }); + + const handleChange = (event: ChangeEvent<{ value: unknown }>) => { + onFontSizeChange(event.target.value as string); + }; + + // Handle focus and blur state changes + const handleFocus = (event: FocusEvent) => { + setIsFocused(true); + if (onFocus) onFocus(event); + }; + + const handleBlur = (event: FocusEvent) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }; + + // Handle dropdown expanded state + const handleDropdownOpen = () => setExpanded(true); + const handleDropdownClose = () => setExpanded(false); + + return ( + + + + Terminal Font Size + + + + + ); +}; + +export default TerminalFontSizeDropdown; diff --git a/src/components/xpath/XPathQueryInput/index.tsx b/src/components/xpath/XPathQueryInput/index.tsx new file mode 100644 index 0000000000000..a66ec3b7f962f --- /dev/null +++ b/src/components/xpath/XPathQueryInput/index.tsx @@ -0,0 +1,69 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import TextField from '@mui/material/TextField'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define props interface +interface XPathQueryInputProps { + value: string; + onChange: (event: ChangeEvent) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const XPathQueryInput: React.FC = ({ value, onChange, onFocus, onBlur }) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + }, + }); + + return ( + + { + setIsFocused(true); + if (onFocus) onFocus(event); + }} + onBlur={(event) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }} + sx={{ + m: 1, + minWidth: 800, + '& .MuiInputLabel-root': { + color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial', + }, + '& .MuiOutlinedInput-root.Mui-focused': { + '& fieldset': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }} + id="outlined-basic-xpath-input" + label="Enter XPath query" + variant="outlined" + value={value} + onChange={onChange} + /> + + ); +}; + +export default XPathQueryInput; diff --git a/src/components/xpath/XPathRootInput/index.tsx b/src/components/xpath/XPathRootInput/index.tsx new file mode 100644 index 0000000000000..3b8c6bdd46cee --- /dev/null +++ b/src/components/xpath/XPathRootInput/index.tsx @@ -0,0 +1,69 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import TextField from '@mui/material/TextField'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define props interface +interface XPathRootInputProps { + value: string; + onChange: (event: ChangeEvent) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const XPathRootInput: React.FC = ({ value, onChange, onFocus, onBlur }) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + }, + }); + + return ( + + { + setIsFocused(true); + if (onFocus) onFocus(event); + }} + onBlur={(event) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }} + sx={{ + m: 1, + minWidth: 800, + '& .MuiInputLabel-root': { + color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial', + }, + '& .MuiOutlinedInput-root.Mui-focused': { + '& fieldset': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }} + id="outlined-basic-xpath-input" + label="Enter XPath root" + variant="outlined" + value={value} + onChange={onChange} + /> + + ); +}; + +export default XPathRootInput; diff --git a/src/components/xpath/useDebounce.ts b/src/components/xpath/useDebounce.ts new file mode 100644 index 0000000000000..481ad379e122d --- /dev/null +++ b/src/components/xpath/useDebounce.ts @@ -0,0 +1,16 @@ +import { useState, useEffect } from 'react'; + +// Define the hook's return type +export function useDebounce(value: T, delay: number): T { + const [debouncedValue, setDebouncedValue] = useState(value); + + useEffect(() => { + const handler = setTimeout(() => { + setDebouncedValue(value); + }, delay); + + return () => clearTimeout(handler); + }, [value, delay]); + + return debouncedValue; +} diff --git a/src/pages/tools/EscapeTool.module.css b/src/pages/tools/EscapeTool.module.css index 7187a01c6cbf5..daa975baa60dd 100644 --- a/src/pages/tools/EscapeTool.module.css +++ b/src/pages/tools/EscapeTool.module.css @@ -31,12 +31,12 @@ background: var(--terminal-background) !important; } -a[id^='jsonpathDocumentationLink'] { +a[id^='xpathDocumentationLink'] { color: var(--link-color) !important; text-decoration: underline !important; } -a[id^='jsonpathDocumentationLink']:hover { +a[id^='xpathDocumentationLink']:hover { text-decoration: none !important; } @@ -51,15 +51,15 @@ div[id^='implementation-dropdown-select'] { color: var(--ifm-primary-text-color); } -input[id^='outlined-basic-jsonpath-input'], -label[id^='outlined-basic-jsonpath-input-label'], +input[id^='outlined-basic-xpath-input'], +label[id^='outlined-basic-xpath-input-label'], select[id^='terminal-font-size-select'], label[id^='terminal-font-size-label'], select[id^='implementation-dropdown-select'], label[id^='implementation-dropdown-label'] { color: var(--ifm-primary-text-color); } -input[id^='outlined-basic-jsonpath-input'], +input[id^='outlined-basic-xpath-input'], div[id^='terminal-font-size-select'], div[id^='implementation-dropdown-select'] { background: var(--terminal-background); @@ -84,7 +84,7 @@ span[class^='ace_string'] { color: var(--terminal-value) !important; } -div [id^='jsonpathalert'] { +div [id^='xpathalert'] { color: rgb(244, 67, 54); border: 1px solid rgb(244, 67, 54); } diff --git a/src/pages/tools/sample.xml.json b/src/pages/tools/sample.xml.json new file mode 100644 index 0000000000000..c4935a5ff0468 --- /dev/null +++ b/src/pages/tools/sample.xml.json @@ -0,0 +1 @@ +{"xml":"<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xhr="urn:com.xylophonichr/api">
  <soap:Body>
    <xhr:GetEmployees_Response xhr:version="v12.0">

      <!-- ============================================================ -->
      <!-- PAGINATION METADATA                                          -->
      <!-- ============================================================ -->
      <xhr:Response_Filter>
        <xhr:Effective_As_Of_Date>2026-03-30</xhr:Effective_As_Of_Date>
        <xhr:Effective_As_Of_DateTime>2026-03-30T12:00:00.000-07:00</xhr:Effective_As_Of_DateTime>
        <xhr:Page>1</xhr:Page>
        <xhr:Page_Size>100</xhr:Page_Size>
      </xhr:Response_Filter>

      <xhr:Response_Summary>
        <xhr:Total_Records>4</xhr:Total_Records>
        <xhr:Total_Pages>1</xhr:Total_Pages>
        <xhr:Records_On_Page>4</xhr:Records_On_Page>
        <xhr:Current_Page>1</xhr:Current_Page>
      </xhr:Response_Summary>

      <xhr:Response_Data>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 1 — Active, Full-Time, US-based                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">a4c9e17f2b6d48a3901e7c5f83d2b0a6</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-204817</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-204817</xhr:Employee_Number>
            <xhr:Login_ID>kpatel</xhr:Login_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <xhr:Personal_Data>

              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Title>Ms.</xhr:Title>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Middle_Name>Rani</xhr:Middle_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Suffix/>
                    <xhr:Display_Name>Kavita Rani Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita Rani</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Display_Name>Kavita Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>

                <!-- Work Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.patel@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Personal Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.r.patel@outlook.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Work Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>415</xhr:Area_Code>
                  <xhr:Number>555-0132</xhr:Number>
                  <xhr:Extension>4420</xhr:Extension>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (415) 555-0132 x4420</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Mobile Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>650</xhr:Area_Code>
                  <xhr:Number>555-0278</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (650) 555-0278</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Home Address -->
                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-01-10T08:15:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">1847 Lombard Street</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Unit 6</xhr:Line>
                  <xhr:City>San Francisco</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>California</xhr:Region_Name>
                  <xhr:Postal_Code>94123</xhr:Postal_Code>
                  <xhr:Formatted_Address>1847 Lombard Street, Unit 6, San Francisco, CA 94123, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1990-04-18</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2020-08-15</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-7890</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>2008-06-20</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-10482</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>PKT-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Parking_Permit</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-009213</xhr:Position_ID>
                  <xhr:Position_Title>Principal Data Engineer</xhr:Position_Title>
                  <xhr:Business_Title>Principal Data Engineer</xhr:Business_Title>
                  <xhr:Start_Date>2024-02-12</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">7bc6640c8af459c6bf99d4b02c59d001</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-009213</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DATA-ENG-P</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Principal Data Engineer</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Data-Engineering</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">REG-WEST</xhr:ID>
                        <xhr:ID xhr:type="Region_Org_Code">REG-WEST</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Western Region</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Region</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2022-08-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2022-08-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2022-08-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2022-08-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2022-08-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2022-08-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2022-08-01</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2022-08-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Probation_Start_Date>2022-08-01</xhr:Probation_Start_Date>
                  <xhr:Probation_End_Date>2023-02-01</xhr:Probation_End_Date>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 2 — Terminated (Voluntary Resignation)              -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">8dd7761e9bf54ac7b011e5c23d70fa92</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-187293</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-187293</xhr:Employee_Number>
            <xhr:Login_ID>tchen</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>tao.chen@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>312</xhr:Area_Code>
                  <xhr:Number>555-0491</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (312) 555-0491</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2024-03-22T10:45:00.000-06:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">440 North Wabash Avenue</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Apt 2701</xhr:Line>
                  <xhr:City>Chicago</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Illinois</xhr:Region_Name>
                  <xhr:Postal_Code>60611</xhr:Postal_Code>
                  <xhr:Formatted_Address>440 North Wabash Avenue, Apt 2701, Chicago, IL 60611, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1985-12-09</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344bb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">CN</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2015-05-20</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-3456</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-006744</xhr:Position_ID>
                  <xhr:Position_Title>Marketing Manager</xhr:Position_Title>
                  <xhr:Business_Title>Senior Marketing Manager</xhr:Business_Title>
                  <xhr:Start_Date>2023-03-01</xhr:Start_Date>
                  <xhr:End_Date>2026-01-15</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">ccd8e9f0a1b2c3d4e5f6a7b8c9d0e1f2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-006744</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">aa11bb22cc33dd44ee55ff6600778899</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-MKT-MGR</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Marketing Manager</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">bb22cc33dd44ee55ff66007788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Marketing</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">cc33dd44ee55ff660077889900112233</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Marketing</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Chicago Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344aa</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-CHI-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">233 South Wacker Drive</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Suite 4800</xhr:Line>
                      <xhr:City>Chicago</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Illinois</xhr:Region_Name>
                      <xhr:Postal_Code>60606</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ee55ff660077889900112233445566bb</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">MKT-BRAND-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">ff660077889900112233445566778899</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-5200</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-5200</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Marketing - Brand</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">1122334455667788990011aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-176002</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>false</xhr:Is_Active>
                  <xhr:Active_Status_Date>2021-09-15</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2021-09-15</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2021-09-15</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-01-15</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2021-09-15</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2021-09-15</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2021-09-15</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2021-09-15</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2021-09-15</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>true</xhr:Is_Terminated>
                  <xhr:Termination_Date>2026-01-15</xhr:Termination_Date>
                  <xhr:Pay_Through_Date>2026-01-31</xhr:Pay_Through_Date>
                  <xhr:Termination_Category_Reference>
                    <xhr:ID xhr:type="GID">aabb1122ccdd3344eeff5566aabb7788</xhr:ID>
                    <xhr:ID xhr:type="Termination_Category_Code">Voluntary</xhr:ID>
                  </xhr:Termination_Category_Reference>
                  <xhr:Primary_Termination_Reason_Reference>
                    <xhr:ID xhr:type="GID">ccdd3344eeff5566aabb778899001122</xhr:ID>
                    <xhr:ID xhr:type="Termination_Reason_Code">Resignation_New_Opportunity</xhr:ID>
                  </xhr:Primary_Termination_Reason_Reference>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Not_Returning>true</xhr:Not_Returning>
                  <xhr:Resignation_Date>2025-12-15</xhr:Resignation_Date>
                  <xhr:Last_Day_of_Work>2026-01-14</xhr:Last_Day_of_Work>
                  <xhr:Eligible_for_Rehire_Reference>
                    <xhr:ID xhr:type="GID">eeff5566aabb778899001122ccdd3344</xhr:ID>
                    <xhr:ID xhr:type="Rehire_Eligibility_Code">Yes</xhr:ID>
                  </xhr:Eligible_for_Rehire_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 3 — Active, On Leave (Parental)                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">f7e6d5c4b3a2918070605040302010ff</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-211305</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-211305</xhr:Employee_Number>
            <xhr:Login_ID>sjohansson</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">SWE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Middle_Name>Linnéa</xhr:Middle_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Linnéa Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia Linnéa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@proton.me</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>206</xhr:Area_Code>
                  <xhr:Number>555-0834</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (206) 555-0834</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-06-01T11:00:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">3014 NE 55th Street</xhr:Line>
                  <xhr:City>Seattle</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Washington</xhr:Region_Name>
                  <xhr:Postal_Code>98105</xhr:Postal_Code>
                  <xhr:Formatted_Address>3014 NE 55th Street, Seattle, WA 98105, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1993-02-14</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Domestic_Partnership</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2023-01-10</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-5512</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <!-- Note: also holds a Swedish personal identity number -->
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>930214-XXXX</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">SWE-PIN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>1993-02-14</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-010881</xhr:Position_ID>
                  <xhr:Position_Title>UX Research Lead</xhr:Position_Title>
                  <xhr:Business_Title>UX Research Lead</xhr:Business_Title>
                  <xhr:Start_Date>2024-06-01</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>0</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">1122aabb3344ccdd5566eeff7788a1b2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-010881</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">bb11cc22dd33ee44ff550066778899aa</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-UXR-LEAD</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>UX Research Lead</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">cc22dd33ee44ff5500667788990011bb</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Design</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">dd33ee44ff550066778899001122ccbb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Design-Research</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Seattle Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">ee44ff55006677889911223344556677</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SEA-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">701 Pike Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 8</xhr:Line>
                      <xhr:City>Seattle</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Washington</xhr:Region_Name>
                      <xhr:Postal_Code>98101</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ff5500667788990011223344556677aa</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">DES-RESEARCH-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">00667788990011223344556677889900</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-8300</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-8300</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Design - Research</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">2233445566778899aabb0011ccddeeff</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-201440</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2023-04-10</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2023-04-10</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2023-04-10</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2023-04-10</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2023-04-10</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2023-04-10</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2023-04-10</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2023-04-10</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Leave of Absence fields — only present when on leave -->
                  <xhr:On_Leave>true</xhr:On_Leave>
                  <xhr:Leave_Start_Date>2026-02-03</xhr:Leave_Start_Date>
                  <xhr:Expected_Return_Date>2026-08-03</xhr:Expected_Return_Date>
                  <xhr:Leave_Type_Reference>
                    <xhr:ID xhr:type="GID">7788990011223344556677aabbccdd00</xhr:ID>
                    <xhr:ID xhr:type="Leave_Type_Code">Parental_Leave</xhr:ID>
                  </xhr:Leave_Type_Reference>
                  <xhr:Leave_Request_Reference>
                    <xhr:ID xhr:type="GID">8899001122334455667788aabbccdd11</xhr:ID>
                    <xhr:ID xhr:type="Leave_Request_ID">LR-2026-000412</xhr:ID>
                  </xhr:Leave_Request_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 4 — Contingent Worker (Contractor)                  -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">0102030405060708090a0b0c0d0e0f10</xhr:ID>
            <xhr:ID xhr:type="Contingent_Worker_Number">CW-400091</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>CW-400091</xhr:Employee_Number>
            <xhr:Login_ID>mnakamura.ext</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">JPN</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masato</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masato Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masato</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masa</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masa Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>masato.nakamura.ext@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>408</xhr:Area_Code>
                  <xhr:Number>555-0612</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (408) 555-0612</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Note: No home address on file for contingent workers — common pattern -->

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1987-09-30</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <!-- No marital status — not collected for contingent workers -->
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <!-- Contingent workers may have no national IDs on file -->
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>VENDOR-TECHSTAR-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Vendor_Worker_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-EXT-7721</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-CW-0412</xhr:Position_ID>
                  <xhr:Position_Title>Staff Augmentation - DevOps</xhr:Position_Title>
                  <xhr:Business_Title>DevOps Engineer (Contract)</xhr:Business_Title>
                  <xhr:Start_Date>2025-10-01</xhr:Start_Date>
                  <xhr:End_Date>2026-09-30</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">aabb0011ccdd2233eeff4455667788cc</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-CW-0412</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Contingent_Worker</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">cc11dd22ee33ff440055667788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DEVOPS-CW</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>DevOps Engineer (Contract)</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788990011223344aabb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Infrastructure</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Hourly</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <!-- Vendor / Staffing Agency reference — unique to contingent workers -->
                  <xhr:Staffing_Agency_Reference>
                    <xhr:ID xhr:type="GID">1100aabb2233ccdd4455eeff66778800</xhr:ID>
                    <xhr:ID xhr:type="Vendor_Code">VENDOR-TECHSTAR</xhr:ID>
                  </xhr:Staffing_Agency_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2025-10-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2025-10-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2025-10-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-09-30</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2025-10-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2025-10-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2025-10-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date/>
                  <xhr:Company_Service_Date>2025-10-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Contract End — only present for contingent workers -->
                  <xhr:Contract_End_Date>2026-09-30</xhr:Contract_End_Date>
                  <xhr:Contract_Renewable>true</xhr:Contract_Renewable>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

      </xhr:Response_Data>
    </xhr:GetEmployees_Response>
  </soap:Body>
</soap:Envelope>"} \ No newline at end of file diff --git a/src/pages/tools/xpath-evaluator.tsx b/src/pages/tools/xpath-evaluator.tsx new file mode 100644 index 0000000000000..9f377a87706be --- /dev/null +++ b/src/pages/tools/xpath-evaluator.tsx @@ -0,0 +1,482 @@ +import React, {useEffect, useRef, useState} from 'react'; +import Layout from '@theme/Layout'; +import styles from './xpath.module.css'; +import Alert from '@mui/material/Alert'; +import Stack from '@mui/material/Stack'; +import Link from '@mui/material/Link'; +import TerminalFontSizeDropdown from '../../components/xpath/TerminalFontSizeDropdown'; +import InputTerminal from '../../components/xpath/InputTerminal'; +import type {HoverValuePayload} from '../../components/xpath/InputTerminal'; +import ResultTerminal from '../../components/xpath/ResultTerminal'; +import XPathRootInput from '../../components/xpath/XPathRootInput'; +import { + evaluateXPathMappings, + XPathEvaluationError, + type AttributeMappings, +} from '../../services/XPathService'; +import Button from '@mui/material/Button'; + +// Define the type for implementation options +type ImplementationType = 'XPath'; +type HoverXPathMatch = { + occurrence: number; + elementPath: string; + exactNodePath: string; +}; + +// Define the documentation links type +const documentationLinks: Record< + ImplementationType, + {url: string; text: string} +> = { + XPath: { + url: 'https://en.wikipedia.org/wiki/XPath', + text: 'XPath Documentation', + }, +}; +const sampleXmlFile = require('./sample.xml.json'); +let buffer = Buffer.from(sampleXmlFile.xml, 'base64'); +const sampleXml = buffer.toString(); + +const XPathEvaluator: React.FC = () => { + const [result, setResult] = useState(JSON.stringify([], null, 4)); + const [attributeMappingsInput, setAttributeMappingsInput] = useState( + JSON.stringify( + { + firstName: + 'xhr:Employee_Data/xhr:Personal_Data/xhr:Name_Data/xhr:Legal_Name/xhr:Name_Detail/xhr:First_Name', + lastName: + 'xhr:Employee_Data/xhr:Personal_Data/xhr:Name_Data/xhr:Legal_Name/xhr:Name_Detail/xhr:Last_Name', + employeeId: + "xhr:Employee_Reference/xhr:ID[@xhr:type='Employee_Number']", + phoneNumber: + 'xhr:Employee_Data/xhr:Personal_Data/xhr:Contact_Data/xhr:Phone/xhr:Formatted_Number', + workRegion: + "xhr:Employee_Data/xhr:Employment_Data/xhr:Worker_Job_Data/xhr:Position_Data/xhr:Business_Site_Summary_Data[xhr:Usage/xhr:Type_Info/@xhr:Primary='true']/xhr:Address/xhr:Region_Reference/xhr:ID[@xhr:type='Region_Code']", + ssnNationalId: + "xhr:Employee_Data/xhr:Personal_Data/xhr:Identification_Data/xhr:National_ID[xhr:National_ID_Detail/xhr:ID_Type_Reference/xhr:ID[@xhr:type='National_ID_Type']='USA-SSN']/xhr:National_ID_Detail/xhr:Value" + }, + null, + 2, + ), + ); + const [root, setRoot] = useState('//xhr:Response_Data/xhr:Employee'); + const [queryParseError, setQueryParseError] = useState(''); + const [isAttributeMappingsParseError, setIsAttributeMappingsParseError] = + useState(false); + const [fontSize, setFontSize] = useState('16'); + const implementation: ImplementationType = 'XPath'; + const inputXml = sampleXml; + const [localXml, setLocalXml] = useState(inputXml); + const [xmlParseError, setXmlParseError] = useState(false); + const [hoverXPathHintMessage, setHoverXPathHintMessage] = useState( + 'Hover an XML value to see its XPath.', + ); + const [hoverXPathMatches, setHoverXPathMatches] = useState( + [], + ); + const [isHoverLocked, setIsHoverLocked] = useState(false); + const [lockedHoverValue, setLockedHoverValue] = + useState(null); + const hoverClearTimeoutRef = useRef(null); + const lastRenderedHoverKeyRef = useRef(''); + + const getElementXPath = (element: Element): string => { + const segments: string[] = []; + let current: Element | null = element; + + while (current) { + segments.unshift(current.tagName); + current = current.parentElement; + } + + return `/${segments.join('/')}`; + }; + + const resolveXPathForValue = ( + xml: string, + hoveredNode: HoverValuePayload, + ): { + matches: HoverXPathMatch[]; + message: string; + } => { + const value = hoveredNode.value.trim(); + if (!value) { + return { + matches: [], + message: 'Hover an XML value to see its XPath.', + }; + } + + try { + const parser = new DOMParser(); + const xmlDoc = parser.parseFromString(xml, 'application/xml'); + if (xmlDoc.getElementsByTagName('parsererror').length > 0) { + return { + matches: [], + message: 'XPath hint unavailable (invalid XML).', + }; + } + + const matches: HoverXPathMatch[] = []; + const elements = Array.from(xmlDoc.getElementsByTagName('*')); + + for (const element of elements) { + const elementPath = getElementXPath(element); + + if (hoveredNode.nodeKind === 'attribute') { + for (const attribute of Array.from(element.attributes)) { + if (attribute.value === value) { + const exactNodePath = `${elementPath}/@${attribute.name}`; + matches.push({ + occurrence: matches.length + 1, + elementPath, + exactNodePath, + }); + } + } + } else { + for (const childNode of Array.from(element.childNodes)) { + if ( + childNode.nodeType === Node.TEXT_NODE && + childNode.textContent?.trim() === value + ) { + const exactNodePath = `${elementPath}/text()`; + matches.push({ + occurrence: matches.length + 1, + elementPath, + exactNodePath, + }); + } + } + } + } + + if (matches.length === 0) { + return { + matches: [], + message: `No XPath match found for "${value}".`, + }; + } + + const selectedIndex = Math.min( + Math.max(hoveredNode.occurrenceIndex, 0), + matches.length - 1, + ); + const selectedMatch = matches[selectedIndex]; + + return { + matches: [selectedMatch], + message: `Showing selected node match for "${value}" (${matches.length} total matches).`, + }; + } catch (_error) { + return { + matches: [], + message: 'XPath hint unavailable.', + }; + } + }; + + // Apply XPath query + const parseAttributeMappings = ( + mappingsJson: string, + ): AttributeMappings | null => { + try { + const parsed = JSON.parse(mappingsJson) as unknown; + + if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) { + setQueryParseError( + 'Attribute mappings must be a JSON object (for example: {"id":"./id"}).', + ); + setIsAttributeMappingsParseError(true); + return null; + } + + const mappings: AttributeMappings = {}; + for (const [attributeId, expression] of Object.entries(parsed)) { + if (typeof expression !== 'string') { + setQueryParseError( + `Attribute mapping '${attributeId}' must be an XPath string value.`, + ); + setIsAttributeMappingsParseError(true); + return null; + } + mappings[attributeId] = expression; + } + + if (Object.keys(mappings).length === 0) { + setQueryParseError('Add at least one attribute mapping XPath pair.'); + setIsAttributeMappingsParseError(true); + return null; + } + + return mappings; + } catch (_error) { + setQueryParseError( + 'Attribute mappings must be valid JSON (for example: {"id":"./id"}).', + ); + setIsAttributeMappingsParseError(true); + return null; + } + }; + + // Apply XPath query + const applyXPathQuery = ( + xml: string, + root: string, + attributeMappingsJson: string, + ) => { + const attributeMappings = parseAttributeMappings(attributeMappingsJson); + if (!attributeMappings) { + setResult('[]'); + return; + } + + try { + let result: any; + + switch (implementation) { + case 'XPath': + // Evaluated entirely in the browser; no Lambda round trip. + result = evaluateXPathMappings(attributeMappings, root, xml); + break; + } + + setResult( + result.length > 0 || + typeof result === 'number' || + typeof result === 'object' || + typeof result === 'boolean' + ? JSON.stringify(result, null, 2) + : 'No match', + ); + setQueryParseError(''); + setIsAttributeMappingsParseError(false); + setXmlParseError(false); + } catch (error: any) { + setResult('No match'); + // Only flag the XML input terminal when the XML itself failed to + // parse; query/root-path syntax errors surface via the alert only. + setXmlParseError( + error instanceof XPathEvaluationError && error.kind === 'xml-parse', + ); + setQueryParseError(error.message || 'Error executing XPath query'); + } + }; + + // Handle input change + const handleXmlChange = (newxml: string) => { + setLocalXml(newxml); + setHoverXPathHintMessage('Hover over an XML value to see its XPath.'); + setHoverXPathMatches([]); + setIsHoverLocked(false); + setLockedHoverValue(null); + if (hoverClearTimeoutRef.current !== null) { + window.clearTimeout(hoverClearTimeoutRef.current); + hoverClearTimeoutRef.current = null; + } + lastRenderedHoverKeyRef.current = ''; + }; + + const handleXmlHoverValueChange = (hoveredNode: HoverValuePayload | null) => { + if (isHoverLocked) { + return; + } + if (hoverClearTimeoutRef.current !== null) { + window.clearTimeout(hoverClearTimeoutRef.current); + hoverClearTimeoutRef.current = null; + } + if (!hoveredNode) { + // Prevent visual jitter when the cursor briefly crosses XML punctuation. + hoverClearTimeoutRef.current = window.setTimeout(() => { + setHoverXPathHintMessage('Hover over an XML value to see its XPath.'); + setHoverXPathMatches([]); + lastRenderedHoverKeyRef.current = ''; + hoverClearTimeoutRef.current = null; + }, 120); + return; + } + const hoverKey = `${hoveredNode.nodeKind}:${hoveredNode.value}:${hoveredNode.occurrenceIndex}`; + if (lastRenderedHoverKeyRef.current === hoverKey) { + return; + } + const hoverData = resolveXPathForValue(localXml, hoveredNode); + setHoverXPathHintMessage(hoverData.message); + setHoverXPathMatches(hoverData.matches); + lastRenderedHoverKeyRef.current = hoverKey; + }; + + const handleXmlHoverLock = (hoveredNode: HoverValuePayload | null) => { + if (!hoveredNode) { + return; + } + if (hoverClearTimeoutRef.current !== null) { + window.clearTimeout(hoverClearTimeoutRef.current); + hoverClearTimeoutRef.current = null; + } + const hoverData = resolveXPathForValue(localXml, hoveredNode); + setHoverXPathHintMessage(`LOCKED: ${hoverData.message}`); + setHoverXPathMatches(hoverData.matches); + setIsHoverLocked(true); + setLockedHoverValue(hoveredNode); + }; + + const resetHoverLock = () => { + setIsHoverLocked(false); + setHoverXPathHintMessage('Hover an XML value to see its XPath.'); + setHoverXPathMatches([]); + setLockedHoverValue(null); + lastRenderedHoverKeyRef.current = ''; + }; + + useEffect(() => { + return () => { + if (hoverClearTimeoutRef.current !== null) { + window.clearTimeout(hoverClearTimeoutRef.current); + } + }; + }, []); + + // Handle root input change + const handleRootChange = (event: React.ChangeEvent) => { + setRoot(event.target.value); + }; + + // Run button handler + const handleRunQuery = () => { + applyXPathQuery(localXml, root, attributeMappingsInput); + }; + + return ( + +
+
+
+ + + + {documentationLinks[implementation] && ( + + {documentationLinks[implementation].text} + + )} + {queryParseError && ( +
+ + {queryParseError} + +
+ )} + + + + + + + + +
+ + + + + + +
+
+ {isHoverLocked ? 'XPath Hover (Locked)' : 'XPath Hover'} + +
+
Click a selected XML value to lock output to that variable.
+
{hoverXPathHintMessage}
+
+ Exact selected node XPath +
+ {hoverXPathMatches.map((match, index) => ( +
+
+ Element path: {match.elementPath} +
+
+ Exact node path: {match.exactNodePath} +
+
+ ))} +
+
+
+ + ); +}; + +export default XPathEvaluator; diff --git a/src/pages/tools/xpath.module.css b/src/pages/tools/xpath.module.css new file mode 100644 index 0000000000000..0748eedf6b06f --- /dev/null +++ b/src/pages/tools/xpath.module.css @@ -0,0 +1,168 @@ +.containerFluid { + margin: 20px; +} + +.actionBar { + margin-top: 2%; + margin-bottom: 2%; +} + +.alertContainer { + min-height: 50px; +} + +.inputTerminalContainer { + border: 3px solid red !important; + background: var(--terminal-background) !important; +} + +.terminalContainerDefault { + border: 3px solid var(--dev-card-background) !important; + background: var(--terminal-background) !important; +} + +a[id^='xpathDocumentationLink'] { + color: var(--link-color) !important; + text-decoration: underline !important; +} + +a[id^='xpathDocumentationLink']:hover { + text-decoration: none!important; +} + +li[class^='MuiButtonBase-root'] { + color: var(--ifm-primary-text-color); +} +div[class^='MuiFormControl-root'] { + color: var(--ifm-primary-text-color); +} +div[id^='terminal-font-size-select'], +div[id^='implementation-dropdown-select'] { + color: var(--ifm-primary-text-color); +} + +input[id^='outlined-basic-xpath-input'], +label[id^='outlined-basic-xpath-input-label'], +select[id^='terminal-font-size-select'], +label[id^='terminal-font-size-label'], +select[id^='implementation-dropdown-select'], +label[id^='implementation-dropdown-label'] { + color: var(--ifm-primary-text-color); +} +input[id^='outlined-basic-xpath-input'], +div[id^='terminal-font-size-select'], +div[id^='implementation-dropdown-select'] { + background: var(--terminal-background); +} +fieldset[class^='MuiOutlinedInput-notchedOutline css-1ll44ll-MuiOutlinedInput-notchedOutline'] { + border: 1.5px solid var(--terminal-background); +} +ul[class^='MuiList-root MuiList-padding MuiMenu-list css-1toxriw-MuiList-root-MuiMenu-list'] { + background-color: var(--terminal-background); +} +ul[class^='MuiMenu-list'] { + background-color: var(--terminal-background); +} +div[class^='MuiPaper-root'] { + background-color: var(--terminal-background) !important; +} + +span[class^='ace_variable'] { + color: var(--terminal-key) !important; +} +span[class^='ace_string'] { + color: var(--terminal-value) !important; +} + +div [id^='xpathalert'] { + color: rgb(244, 67, 54); + border: 1px solid rgb(244, 67, 54); +} + +.actionBar button { + min-width: 100px; +} + +.runButton { + color: var(--ifm-button-colors) !important; + border: 1px solid var(--ifm-button-colors) !important; + background-color: var(--dropdown-background) !important; +} + +.runButton:hover { + background-color: var(--ifm-button-colors) !important; + color: var(--text-on-primary) !important; + border: 1px solid var(--ifm-button-colors) !important; +} + +.hoverHint { + margin-top: 8px; + font-family: monospace; + font-size: 0.9rem; + color: var(--ifm-font-color-base); + word-break: break-word; + border: 1px solid transparent; + border-radius: 6px; + padding: 8px; + height: 240px; + overflow-y: scroll; + scrollbar-gutter: stable; + overflow-anchor: none; +} + +.hoverHintMatch { + margin-top: 8px; + padding: 8px; + border: 1px solid var(--dev-card-background); + border-radius: 4px; +} + +.hoverResultsSectionTitle { + margin-top: 10px; + font-weight: 700; + font-size: 0.85rem; + text-transform: uppercase; + letter-spacing: 0.03em; +} + +.hoverHintLocked { + border-color: var(--ifm-color-warning); + box-shadow: 0 0 0 1px var(--ifm-color-warning); +} + +.hoverHeader { + display: flex; + align-items: center; + justify-content: flex-start; + gap: 12px; + margin-bottom: 8px; +} + +.resetHoverButton { + border: 1px solid; + border-radius: 4px; + background: transparent; + font-size: 0.85rem; + padding: 4px 8px; +} + +.resetHoverButtonActive { + color: var(--ifm-color-warning-dark); + border-color: var(--ifm-color-warning-dark); + background-color: var(--ifm-color-warning-lightest); + cursor: pointer; +} + +.resetHoverButtonDisabled { + color: var(--ifm-color-emphasis-500); + border-color: var(--ifm-color-emphasis-300); + background-color: var(--ifm-color-emphasis-100); + cursor: not-allowed; +} + +:global(.ace_marker-layer .locked-hover-selection) { + position: absolute; + background-color: rgba(255, 193, 7, 0.35); + border-bottom: 2px solid var(--ifm-color-warning-dark); + z-index: 20; +} diff --git a/src/services/XPathService.ts b/src/services/XPathService.ts new file mode 100644 index 0000000000000..3210817051bc0 --- /dev/null +++ b/src/services/XPathService.ts @@ -0,0 +1,277 @@ +/* Copyright (c) 2026. SailPoint Technologies, Inc. All rights reserved. */ + +/** + * Client-side XPath evaluation service. + * + * This is a TypeScript port of the XML response parsing logic used by the + * Web Services connector (previously hosted as an AWS Lambda). It evaluates + * a root path against an XML document to produce a node list, then evaluates + * one or more attribute-mapping XPath expressions against each node to build + * resource objects — mirroring how the connector parses XML responses. + * + * It runs entirely in the browser. `@xmldom/xmldom` and `xpath` are pure + * JavaScript (no reliance on `window`/`document`), so this module is also + * safe to import during Docusaurus server-side rendering. + */ + +import {DOMParser, MIME_TYPE, onErrorStopParsing} from '@xmldom/xmldom'; +import * as xpath from 'xpath'; + +/** A single parsed resource: attribute-mapping name → extracted value(s). */ +export type XPathResource = Record; + +/** Attribute-mapping name → XPath expression (relative to each root node). */ +export type AttributeMappings = Record; + +/** Namespace prefix → URI. */ +export type NamespaceMappings = Record; + +/** Distinguishes XML parse failures from XPath evaluation failures. */ +export class XPathEvaluationError extends Error { + constructor( + message: string, + public readonly kind: 'xml-parse' | 'xpath', + ) { + super(message); + this.name = 'XPathEvaluationError'; + } +} + +const DEFAULT_ROOT_PATH = '/'; +const NS_TEMP_PREFIX = 'tempns'; +// Matches xmlns and xmlns:prefix declarations anywhere in the raw document +// text, capturing the prefix (group 1) and URI (group 2). +const REGEX_XMLNS_ATTRS_GROUP = /xmlns:?(\w*)="(\S*)"/g; + +/** + * Extract every namespace declaration from the raw XML text. Default + * (unprefixed) namespaces are assigned synthetic `tempns1`, `tempns2`, ... + * prefixes so they remain addressable in XPath 1.0, which has no concept of + * a default namespace in expressions. + */ +export function extractNamespaces(xmlContent: string): NamespaceMappings { + const namespaces: NamespaceMappings = {}; + let tempPrefixCount = 0; + if (xmlContent) { + for (const match of xmlContent.matchAll(REGEX_XMLNS_ATTRS_GROUP)) { + let prefix = match[1]; + const uri = match[2]; + if (!prefix) { + prefix = NS_TEMP_PREFIX + ++tempPrefixCount; + } + namespaces[prefix] = uri; + } + } + return namespaces; +} + +function normalizeRootPath(rootPath: string | null | undefined): string { + if (!rootPath) { + console.log('XPathService: Root path not configured. Setting to default.'); + return DEFAULT_ROOT_PATH; + } + if (rootPath === '//') { + console.log("XPathService: Root path found '//'. Overriding to '/'."); + return DEFAULT_ROOT_PATH; + } + return rootPath; +} + +/** + * Evaluate one attribute-mapping expression against one root node and store + * the result on the resource object. Errors here are logged and swallowed so + * that a single bad mapping does not prevent the remaining mappings from + * being extracted — matching the connector's lenient per-attribute behavior. + */ +function prepareResource( + resource: XPathResource, + node: Node, + path: string, + attributeMappingKey: string, + select: xpath.XPathSelect, +): void { + try { + const selected = select(path, node); + + if (Array.isArray(selected)) { + if (selected.length > 1) { + const childValues = selected.map((child) => child.textContent ?? ''); + resource[attributeMappingKey] = childValues; + // Salesforce SOAP responses repeat the element twice with + // identical values; collapse the duplicate to a single value. + if (path === 'sf:Id' && childValues[0] === childValues[1]) { + resource[attributeMappingKey] = childValues[0]; + } + } else if (selected.length === 1) { + resource[attributeMappingKey] = selected[0].textContent ?? ''; + } + // Zero matches: attribute intentionally omitted from the resource. + } else if (selected !== undefined && selected !== null) { + // Expressions like string(...), count(...), or boolean(...) return a + // primitive rather than a node list. + resource[attributeMappingKey] = String(selected); + } + } catch (error) { + console.log( + `XPathService: Error parsing value for attribute ${attributeMappingKey} using XPath ${path}:`, + error, + ); + } +} + +/** + * Parse an XML document and extract resource objects. + * + * @param rawXml XML document as a plain (not base64) string. + * @param rootPath XPath selecting the node(s) each resource is built + * from, e.g. `//xhr:Response_Data/xhr:Employee`. + * @param attributeMappings Attribute name → XPath relative to each root node. + * @param namespaceMappings Optional prefix → URI map. Namespaces declared in + * the document itself are always extracted and used; + * entries provided here take precedence on conflict. + * @returns One resource object per node matched by `rootPath`. + * @throws XPathEvaluationError on malformed XML (`kind: 'xml-parse'`) or an + * invalid root path expression (`kind: 'xpath'`). + */ +export function parseResources( + rawXml: string, + rootPath: string, + attributeMappings: AttributeMappings, + namespaceMappings: NamespaceMappings = {}, +): XPathResource[] { + const resources: XPathResource[] = []; + if (!rawXml) { + console.log( + 'XPathService: XML response is empty. Skipping resource parsing.', + ); + return resources; + } + + // Namespaces declared in the document are always available to expressions; + // caller-supplied mappings are merged on top so users can add or override + // prefixes. + const namespaces: NamespaceMappings = { + ...extractNamespaces(rawXml), + ...namespaceMappings, + }; + + let doc; + try { + // onErrorStopParsing makes the parser strict: malformed XML throws + // instead of producing a best-effort partial document. + const parser = new DOMParser({onError: onErrorStopParsing}); + doc = parser.parseFromString(rawXml, MIME_TYPE.XML_TEXT); + } catch (error) { + throw new XPathEvaluationError( + `XML parse error: ${error instanceof Error ? error.message : String(error)}`, + 'xml-parse', + ); + } + + const select = xpath.useNamespaces(namespaces); + + let nodes: xpath.SelectReturnType; + try { + // @xmldom/xmldom nodes implement the W3C DOM interfaces the xpath + // package operates on, but carry their own type declarations; the cast + // bridges the two declaration sets. + nodes = select(normalizeRootPath(rootPath), doc as unknown as Node); + } catch (error) { + throw new XPathEvaluationError( + `Invalid root path: ${error instanceof Error ? error.message : String(error)}`, + 'xpath', + ); + } + + if (!Array.isArray(nodes) || nodes.length === 0) { + console.log( + 'XPathService: Unable to find resource objects for provided root path', + ); + return resources; + } + + for (const node of nodes) { + const resource: XPathResource = {}; + let contextNode: Node | null = null; + + if (node.nodeType === node.ELEMENT_NODE) { + contextNode = node; + } else if (node.nodeType === node.DOCUMENT_NODE) { + contextNode = (node as Document).documentElement; + } + + if (contextNode) { + for (const [attributeMappingKey, path] of Object.entries( + attributeMappings, + )) { + prepareResource( + resource, + contextNode, + path, + attributeMappingKey, + select, + ); + } + } + resources.push(resource); + } + return resources; +} + +/** + * Convenience wrapper for the XPath Evaluator tool: evaluates a single XPath + * expression against each node matched by `rootPath`. + * + * Unlike the multi-mapping `parseResources` (which is lenient per attribute, + * matching the connector), a syntactically invalid query here throws an + * XPathEvaluationError so the tool can show the user an actionable message. + */ +export function evaluateXPath( + xPathQuery: string, + rootPath: string, + xmlData: string, + namespaceMappings: NamespaceMappings = {}, +): XPathResource[] { + return evaluateXPathMappings( + {'XPath Query Result': xPathQuery}, + rootPath, + xmlData, + namespaceMappings, + ); +} + +/** + * Convenience wrapper for the XPath Evaluator tool: evaluates one or more + * attribute-mapping XPath expressions against each node matched by `rootPath`. + */ +export function evaluateXPathMappings( + attributeMappings: AttributeMappings, + rootPath: string, + xmlData: string, + namespaceMappings: NamespaceMappings = {}, +): XPathResource[] { + for (const [attributeName, xPathQuery] of Object.entries(attributeMappings)) { + if (!xPathQuery || !xPathQuery.trim()) { + throw new XPathEvaluationError( + `XPath query for attribute '${attributeName}' is empty`, + 'xpath', + ); + } + + try { + // xpath.parse() is a documented public API of the xpath package, but is + // missing from its bundled type declarations (as of 0.0.34), hence the + // narrow cast. + (xpath as unknown as {parse: (expr: string) => unknown}).parse(xPathQuery); + } catch (error) { + throw new XPathEvaluationError( + `Invalid XPath query for attribute '${attributeName}': ${ + error instanceof Error ? error.message : String(error) + }`, + 'xpath', + ); + } + } + + return parseResources(xmlData, rootPath, attributeMappings, namespaceMappings); +}