@applitools/core 4.69.2 → 4.70.0

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [4.70.0](https://github.com/Applitools-Dev/sdk/compare/js/core@4.69.2...js/core@4.70.0) (2026-09-14)
+
+
+### Features
+
+* synthesize a DOM from the accessibility hierarchy for iOS checks without NML | AD-14691 ([#4112](https://github.com/Applitools-Dev/sdk/issues/4112)) ([ee6e04e](https://github.com/Applitools-Dev/sdk/commit/ee6e04e7b46ce8d530202b9bd40cdce255a74728))
+
 ## [4.69.2](https://github.com/Applitools-Dev/sdk/compare/js/core@4.69.1...js/core@4.69.2) (2026-08-30)
 
 

package/dist/classic/utils/parse-ios-page-source.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIosPageSource = void 0;
+/**
+ * Parses an iOS Appium `getPageSource` document (WebDriverAgent XML) into the
+ * `NativeElementNode` tree consumed by `synthesize-native-dom`. Kept separate
+ * from the synthesizer so the element-type -> HTML mapping stays platform-neutral
+ * and the (platform-specific) source shape lives here.
+ *
+ * WDA emits every element as `<XCUIElementType… type="XCUIElementType…"
+ * label="…" x=".." y=".." width=".." height=".." …>`; `preserveOrder` keeps the
+ * original sibling order, which the dashboard hover/layout relies on.
+ */
+const fast_xml_parser_1 = require("fast-xml-parser");
+const ATTRS = ':@';
+const ATTR_PREFIX = '@_';
+const parser = new fast_xml_parser_1.XMLParser({
+    ignoreAttributes: false,
+    preserveOrder: true,
+    parseAttributeValue: false,
+    // Decode decimal char refs too (`&#10;` for newlines in multi-line labels) — the
+    // default only handles named/hex. Keep label whitespace intact (`trimValues:false`)
+    // so labels match the on-device value; inter-element whitespace becomes stray #text
+    // nodes that `toNativeNode` drops (they aren't XCUIElementType tags).
+    htmlEntities: true,
+    trimValues: false,
+});
+function parseIosPageSource(xml) {
+    var _a;
+    // WDA truncates the page source on deep hierarchies. `parser.parse` accepts a
+    // truncated document (unclosed tags) and returns a partial tree instead of
+    // throwing, so validate first — otherwise we'd upload a partial DOM as complete.
+    if (fast_xml_parser_1.XMLValidator.validate(xml) !== true)
+        return undefined;
+    const top = parser.parse(xml);
+    const aut = top.find(node => Array.isArray(node.AppiumAUT));
+    const children = (_a = aut === null || aut === void 0 ? void 0 : aut.AppiumAUT) !== null && _a !== void 0 ? _a : top;
+    // The root is the first real XCUIElement under <AppiumAUT> (the application).
+    const rootNode = children.find(node => elementTag(node));
+    return rootNode && toNativeNode(rootNode);
+}
+exports.parseIosPageSource = parseIosPageSource;
+function toNativeNode(node) {
+    var _a, _b, _c;
+    const tag = elementTag(node);
+    if (!tag)
+        return undefined;
+    const attrs = (_a = node[ATTRS]) !== null && _a !== void 0 ? _a : {};
+    const type = (_b = attrs[`${ATTR_PREFIX}type`]) !== null && _b !== void 0 ? _b : tag;
+    const label = attrs[`${ATTR_PREFIX}label`];
+    const children = (_c = node[tag]) !== null && _c !== void 0 ? _c : [];
+    return {
+        elementType: caseName(type),
+        frame: toFrame(attrs),
+        label: label != null && label !== '' ? String(label) : undefined,
+        children: children.map(toNativeNode).filter(Boolean),
+    };
+}
+/** The single `XCUIElementType…` key on a parsed node (ignoring the `:@` attrs bag). */
+function elementTag(node) {
+    return Object.keys(node).find(key => key.startsWith('XCUIElementType'));
+}
+/** 'XCUIElementTypeStaticText' -> 'staticText' — the case-name form HTMLNode switches on. */
+function caseName(type) {
+    const name = type.replace(/^XCUIElementType/, '');
+    return name.charAt(0).toLowerCase() + name.slice(1);
+}
+function toFrame(attrs) {
+    const x = Number(attrs[`${ATTR_PREFIX}x`]);
+    const y = Number(attrs[`${ATTR_PREFIX}y`]);
+    const width = Number(attrs[`${ATTR_PREFIX}width`]);
+    const height = Number(attrs[`${ATTR_PREFIX}height`]);
+    if ([x, y, width, height].some(Number.isNaN))
+        return undefined;
+    return { x, y, width, height };
+}

package/dist/classic/utils/synthesize-native-dom.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Synthesizes an Applitools DOM-capture document from a native accessibility
+ * tree — a port of the iOS SDK's `HTMLNode.swift` mapping that must stay in sync
+ * with it. See core/llm-docs/CLASSIC.md ("iOS DOM Synthesis").
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeNativeDom = void 0;
+/** elementType -> tag + static attributes (mirrors the switch in HTMLNode.swift:205-434). */
+const TYPE_MAP = {
+    any: { tag: 'DIV' },
+    other: { tag: 'DIV' },
+    application: { tag: 'DIV' },
+    group: { tag: 'DIV', attrs: { role: 'group' } },
+    window: { tag: 'DIV', attrs: { role: 'window' } },
+    sheet: { tag: 'DIV', attrs: { role: 'dialog' } },
+    drawer: { tag: 'DIV', attrs: { role: 'complementary' } },
+    alert: { tag: 'DIV', attrs: { role: 'alert' } },
+    dialog: { tag: 'DIV', attrs: { role: 'dialog' } },
+    button: { tag: 'BUTTON' },
+    radioButton: { tag: 'INPUT', attrs: { type: 'radio' } },
+    radioGroup: { tag: 'DIV', attrs: { role: 'radiogroup' } },
+    checkBox: { tag: 'INPUT', attrs: { type: 'checkbox' } },
+    disclosureTriangle: { tag: 'BUTTON', attrs: { 'aria-expanded': 'false' } },
+    popUpButton: { tag: 'DIV', attrs: { role: 'listbox' } },
+    comboBox: { tag: 'INPUT', attrs: { role: 'combobox' } },
+    menuButton: { tag: 'BUTTON', attrs: { 'aria-haspopup': 'true' } },
+    toolbarButton: { tag: 'BUTTON' },
+    popover: { tag: 'DIV', attrs: { role: 'dialog' } },
+    keyboard: { tag: 'DIV', attrs: { class: 'keyboard' } },
+    key: { tag: 'KBD', attrs: { class: 'key' } },
+    navigationBar: { tag: 'NAV', attrs: { role: 'navigation' } },
+    tabBar: { tag: 'DIV', attrs: { role: 'tablist' } },
+    tabGroup: { tag: 'DIV', attrs: { role: 'tablist' } },
+    toolbar: { tag: 'DIV', attrs: { role: 'toolbar' } },
+    statusBar: { tag: 'DIV', attrs: { role: 'status' } },
+    table: { tag: 'UL' },
+    collectionView: { tag: 'UL' },
+    tableRow: { tag: 'DIV', attrs: { role: 'row' } },
+    tableColumn: { tag: 'DIV', attrs: { role: 'column' } },
+    outline: { tag: 'UL', attrs: { role: 'tree' } },
+    outlineRow: { tag: 'LI', attrs: { role: 'treeitem' } },
+    browser: { tag: 'CANVAS' },
+    map: { tag: 'CANVAS' },
+    webView: { tag: 'CANVAS' },
+    slider: { tag: 'INPUT', attrs: { type: 'range' } },
+    pageIndicator: { tag: 'DIV', attrs: { class: 'page-indicator' } },
+    progressIndicator: { tag: 'DIV', attrs: { role: 'progressbar' } },
+    activityIndicator: { tag: 'DIV', attrs: { role: 'status' } },
+    segmentedControl: { tag: 'DIV', attrs: { role: 'group' } },
+    picker: { tag: 'DIV', attrs: { role: 'listbox' } },
+    pickerWheel: { tag: 'DIV', attrs: { role: 'listbox' } },
+    switch: { tag: 'INPUT', attrs: { type: 'checkbox', role: 'switch' } },
+    toggle: { tag: 'BUTTON', attrs: { role: 'switch', 'aria-pressed': 'false' } },
+    link: { tag: 'A', attrs: { role: 'link' } },
+    image: { tag: 'IMG' },
+    icon: { tag: 'DIV', attrs: { class: 'icon' } },
+    searchField: { tag: 'INPUT', attrs: { type: 'search' } },
+    scrollView: { tag: 'DIV', attrs: { style: 'overflow:auto;' } },
+    scrollBar: { tag: 'DIV', attrs: { class: 'scrollbar' } },
+    staticText: { tag: 'SPAN' },
+    // textField / secureTextField also set value=label||'' (handled below).
+    textField: { tag: 'INPUT', attrs: { type: 'text' } },
+    secureTextField: { tag: 'INPUT', attrs: { type: 'password' } },
+    datePicker: { tag: 'INPUT', attrs: { type: 'date' } },
+    textView: { tag: 'TEXTAREA' },
+    menu: { tag: 'UL', attrs: { role: 'menu' } },
+    menuItem: { tag: 'LI', attrs: { role: 'menuitem' } },
+    menuBar: { tag: 'DIV', attrs: { role: 'menubar' } },
+    menuBarItem: { tag: 'DIV', attrs: { role: 'menuitem' } },
+    incrementArrow: { tag: 'BUTTON', attrs: { 'aria-label': 'increment' } },
+    decrementArrow: { tag: 'BUTTON', attrs: { 'aria-label': 'decrement' } },
+    timeline: { tag: 'DIV', attrs: { class: 'timeline' } },
+    ratingIndicator: { tag: 'DIV', attrs: { role: 'meter' } },
+    valueIndicator: { tag: 'DIV', attrs: { role: 'output' } },
+    splitGroup: { tag: 'DIV', attrs: { class: 'split-group' } },
+    splitter: { tag: 'DIV', attrs: { role: 'separator' } },
+    relevanceIndicator: { tag: 'DIV', attrs: { 'aria-hidden': 'true' } },
+    colorWell: { tag: 'INPUT', attrs: { type: 'color' } },
+    helpTag: { tag: 'DIV', attrs: { class: 'help-tag' } },
+    matte: { tag: 'DIV', attrs: { class: 'matte' } },
+    dockItem: { tag: 'LI', attrs: { role: 'menuitem' } },
+    ruler: { tag: 'DIV', attrs: { class: 'ruler' } },
+    rulerMarker: { tag: 'DIV', attrs: { class: 'ruler-marker' } },
+    grid: { tag: 'DIV', attrs: { role: 'grid' } },
+    levelIndicator: { tag: 'DIV', attrs: { role: 'meter' } },
+    cell: { tag: 'LI' },
+    layoutArea: { tag: 'DIV', attrs: { class: 'layout-area' } },
+    layoutItem: { tag: 'DIV', attrs: { class: 'layout-item' } },
+    handle: { tag: 'DIV', attrs: { class: 'handle' } },
+    stepper: { tag: 'INPUT', attrs: { type: 'number', role: 'spinbutton' } },
+    tab: { tag: 'BUTTON', attrs: { role: 'tab' } },
+    touchBar: { tag: 'DIV', attrs: { class: 'touchbar' } },
+    statusItem: { tag: 'DIV', attrs: { role: 'status' } },
+};
+function synthesizeNativeDom(root, { source, version, metadata } = {}) {
+    return serialize(build(root, true, { source, version, metadata }));
+}
+exports.synthesizeNativeDom = synthesizeNativeDom;
+function build(node, isRoot, root) {
+    var _a, _b, _c, _d;
+    const attributes = { ...((_a = node.attributes) !== null && _a !== void 0 ? _a : {}) };
+    attributes['elementTypeName'] = node.elementType;
+    const rect = node.frame
+        ? { width: node.frame.width, height: node.frame.height, top: node.frame.y, left: node.frame.x }
+        : undefined;
+    const childNodes = ((_b = node.children) !== null && _b !== void 0 ? _b : []).map(child => build(child, false, root));
+    const mapping = (_c = TYPE_MAP[node.elementType]) !== null && _c !== void 0 ? _c : { tag: 'DIV' };
+    const current = { tagName: mapping.tag, attributes, childNodes, rect };
+    if (mapping.attrs)
+        Object.assign(current.attributes, mapping.attrs);
+    if (node.elementType === 'textField' || node.elementType === 'secureTextField') {
+        current.attributes['value'] = (_d = node.label) !== null && _d !== void 0 ? _d : '';
+    }
+    if (isRoot) {
+        // Wrap: the decoded root element becomes BODY (a value copy — clone attributes so
+        // a later apply() on the HTML node can't leak into BODY), and a fresh HTML node
+        // carries it plus source/version/metadata. Mirrors HTMLNode.swift:436-448.
+        const bodyNode = { ...current, attributes: { ...current.attributes } };
+        bodyNode.tagName = 'BODY';
+        current.childNodes = [bodyNode];
+        current.tagName = 'HTML';
+        if (root.source !== undefined)
+            current.source = root.source;
+        if (root.version !== undefined)
+            current.version = root.version;
+        if (root.metadata !== undefined)
+            current.metadata = root.metadata;
+    }
+    if (node.label)
+        apply(current, node.label);
+    return current;
+}
+/** Mirrors HTMLNode.apply(text:) — HTMLNode.swift:455-491. */
+function apply(node, text) {
+    if (!text)
+        return;
+    switch (node.tagName) {
+        case 'INPUT':
+            node.attributes['value'] = text;
+            break;
+        case 'A':
+            if (node.childNodes.length === 0)
+                node.childNodes.push(textNode(text, node.rect));
+            else
+                node.attributes['title'] = text;
+            break;
+        case '#text':
+            node.text = text;
+            break;
+        case 'HTML':
+            node.attributes['title'] = text;
+            break;
+        case 'BUTTON':
+            // Swift only appends when empty; a labelled button with children keeps its children.
+            if (node.childNodes.length === 0)
+                node.childNodes.push(textNode(text, node.rect));
+            break;
+        case 'IMG':
+            node.attributes['src'] = text;
+            break;
+        default:
+            // A container with children shouldn't also emit a #text child over its full rect
+            // (it would confuse the Eyes UI hover/select) — set a title instead.
+            if (node.childNodes.length === 0)
+                node.childNodes.push(textNode(text, node.rect));
+            else
+                node.attributes['title'] = text;
+    }
+}
+function textNode(text, rect) {
+    return { tagName: '#text', attributes: {}, childNodes: [], rect, text };
+}
+function serialize(node) {
+    const out = { tagName: node.tagName, childNodes: [] };
+    if (Object.keys(node.attributes).length > 0)
+        out.attributes = node.attributes;
+    out.childNodes = node.childNodes.map(serialize);
+    if (node.rect) {
+        // The diff/ignore algo expects #text nodes to carry a `rects` array; all other
+        // tags keep a single `rect` (HTMLNode.swift:63-85).
+        if (node.tagName === '#text')
+            out.rects = [node.rect];
+        else
+            out.rect = node.rect;
+    }
+    if (node.text !== undefined)
+        out.text = node.text;
+    if (node.version !== undefined)
+        out.version = node.version;
+    if (node.source !== undefined)
+        out.source = node.source;
+    if (node.metadata !== undefined)
+        out.metadata = node.metadata;
+    return out;
+}

package/dist/classic/utils/take-ios-dom-capture.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeIosDomCapture = void 0;
+const parse_ios_page_source_1 = require("./parse-ios-page-source");
+const synthesize_native_dom_1 = require("./synthesize-native-dom");
+/**
+ * iOS no-NML counterpart of `takeDomCapture`: reads the accessibility hierarchy
+ * through the driver and synthesizes an Applitools DOM document from it (see
+ * docs/native-dom-without-nml-design.md). Returns undefined — an image-only
+ * check — when the driver has no page source or synthesis fails; a DOM problem
+ * must never fail the check itself.
+ */
+async function takeIosDomCapture({ driver, logger, }) {
+    try {
+        const pageSource = await driver.getPageSource();
+        if (!pageSource)
+            return undefined;
+        const root = (0, parse_ios_page_source_1.parseIosPageSource)(pageSource);
+        if (!root)
+            return undefined;
+        return JSON.stringify((0, synthesize_native_dom_1.synthesizeNativeDom)(root, { source: 'mobile-ios-appium' }));
+    }
+    catch (error) {
+        logger.error('failed to synthesize DOM from the iOS page source', error);
+        return undefined;
+    }
+}
+exports.takeIosDomCapture = takeIosDomCapture;

package/dist/classic/utils/take-screenshots.js

@@ -25,10 +25,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.takeScreenshots = void 0;
 const take_dom_capture_1 = require("./take-dom-capture");
+const take_ios_dom_capture_1 = require("./take-ios-dom-capture");
 const take_screenshot_1 = require("../../automation/utils/take-screenshot");
 const utils = __importStar(require("@applitools/utils"));
 async function takeScreenshots({ driver, settings, logger, }) {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const screenshot = await logger.withTime((0, take_screenshot_1.takeScreenshot)({ driver, settings, logger }), 'takeScreenshot');
     const name = await logger.withTime(driver.getTitle(), 'getTitle');
     const source = await logger.withTime(driver.getUrl(), 'getUrl');
@@ -52,6 +53,27 @@ async function takeScreenshots({ driver, settings, logger, }) {
             return undefined;
         }), 'takeDomCapture');
     }
+    else if (environment.isNative &&
+        environment.isIOS &&
+        !((_c = environment.applitoolsLib) === null || _c === void 0 ? void 0 : _c.instrumented) &&
+        !settings.webview &&
+        settings.domSettings) {
+        // No-NML iOS app: synthesize a DOM from the accessibility hierarchy so the
+        // check still gets layout matching / dashboard hover / RCA. Android pending.
+        const dom = await logger.withTime((0, take_ios_dom_capture_1.takeIosDomCapture)({ driver, logger }), 'takeIosDomCapture');
+        if (dom) {
+            baseTarget.dom = dom;
+            // The native screenshot is cropped below the status bar while the page-source
+            // DOM stays in full-screen coordinates. Shift the reported location down by the
+            // band the screenshoter actually cropped, so the server seats the DOM correctly
+            // (same fix as the iOS SDK's classic no-NML path). Using the screenshoter's own
+            // reported offset keeps this consistent with the pixels for viewport, region and
+            // framed captures alike. Rounded — the server rejects fractional locations.
+            if (screenshot.statusBarOffset) {
+                baseTarget.locationInViewport = utils.geometry.round(utils.geometry.offset((_d = baseTarget.locationInViewport) !== null && _d !== void 0 ? _d : { x: 0, y: 0 }, { x: 0, y: screenshot.statusBarOffset }));
+            }
+        }
+    }
     if (settings.calculateView) {
         const scrollingElement = await driver.mainContext.getScrollingElement();
         const scrollingOffset = !scrollingElement || environment.isNative ? { x: 0, y: 0 } : await scrollingElement.getScrollOffset();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/core",
-  "version": "4.69.2",
+  "version": "4.70.0",
   "homepage": "https://applitools.com",
   "bugs": {
     "url": "https://github.com/applitools/eyes.sdk.javascript1/issues"
@@ -48,17 +48,19 @@
     "build": "yarn build:dist",
     "build:dist": "run --top-level tsc --project ./tsconfig.build.json",
     "test": "run --top-level mocha './test/**/*.spec.ts' --exclude 'test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
-    "test:local": "MOCHA_OMIT_TAGS=sauce,browserstack run test",
+    "test:local": "MOCHA_OMIT_TAGS=sauce,browserstack,ios-simulator run test",
     "test:sauce": "MOCHA_ONLY_TAGS=sauce,browserstack run test",
     "test:bin": "MOCHA_GROUP=bin run --top-level mocha './test/bin/**/*.spec.ts' --parallel --jobs ${MOCHA_JOBS:-15} --require ./test/mocha-global-setup.js",
-    "test:e2e": "MOCHA_OMIT_TAGS=http2 MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --exclude 'test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
-    "test:e2e:http2": "APPLITOOLS_HTTP_VERSION=2 MOCHA_OMIT_TAGS=http1,sauce,browserstack MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --exclude 'test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
+    "test:e2e": "MOCHA_OMIT_TAGS=http2,ios-simulator MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --exclude 'test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
+    "test:e2e:http2": "APPLITOOLS_HTTP_VERSION=2 MOCHA_OMIT_TAGS=http1,sauce,browserstack,ios-simulator MOCHA_GROUP=e2e run --top-level mocha './test/e2e/**/*.spec.ts' --exclude 'test/e2e/mocha-sync/**' --parallel --jobs ${MOCHA_JOBS:-15} --exit --require ./test/mocha-global-setup.js",
     "test:it": "MOCHA_GROUP=it run --top-level mocha './test/it/**/*.spec.ts' --require ./test/mocha-global-setup.js",
     "test:e2e:sync": "MOCHA_GROUP=e2e SYNC=true run --top-level mocha './test/e2e/mocha-sync/**/*.spec.ts' --exit --require ./test/mocha-global-setup.js",
     "test:unit": "MOCHA_GROUP=unit run --top-level mocha './test/unit/**/*.spec.ts' --require ./test/mocha-global-setup.js",
     "setup": "run --top-level browsers:setup && run --top-level xvfb:setup && run playwright:setup",
     "playwright:setup": "node -e \"var v=parseInt(process.version.slice(1));if(v>=18){require('child_process').execSync('yarn playwright install --with-deps firefox',{stdio:'inherit'})}else{console.log('Skipping playwright install (Node '+process.version+')')}\"",
-    "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'"
+    "setup:standalone": "sh -c 'yarn chromedriver --port=4444 --verbose &'",
+    "setup:ios-simulator": "npx --yes appium@3 driver install xcuitest && cd ../../../test/apps/ios/IOSTestApp && xcodebuild -project IOSTestApp.xcodeproj -target IOSTestApp -configuration Release -sdk iphonesimulator CODE_SIGNING_ALLOWED=NO SYMROOT=build build",
+    "test:ios-simulator": "MOCHA_ONLY_TAGS=ios-simulator MOCHA_GROUP=ios-simulator run --top-level mocha ./test/e2e/classic/webview.spec.ts --exit --require ./test/mocha-global-setup.js"
   },
   "dependencies": {
     "@applitools/core-base": "1.38.2",
@@ -77,6 +79,7 @@
     "@applitools/utils": "1.15.2",
     "abort-controller": "3.0.0",
     "chalk": "4.1.2",
+    "fast-xml-parser": "5.11.1",
     "node-fetch": "2.6.7",
     "semver": "7.6.2",
     "shell-quote": "^1.8.4",

package/types/automation/utils/take-screenshot.d.ts

@@ -13,6 +13,8 @@ export type Screenshot<TSpec extends SpecType> = {
         selector?: Selector;
         regions: Region[];
     }[];
+    /** Points the native status bar was cropped from the image top (0 if kept or on web). */
+    statusBarOffset: number;
 };
 export declare function takeScreenshot<TSpec extends SpecType>({ driver, settings, logger, }: {
     driver: Driver<TSpec>;

package/types/classic/utils/parse-ios-page-source.d.ts

@@ -0,0 +1,2 @@
+import type { NativeElementNode } from './synthesize-native-dom';
+export declare function parseIosPageSource(xml: string): NativeElementNode | undefined;

package/types/classic/utils/synthesize-native-dom.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Synthesizes an Applitools DOM-capture document from a native accessibility
+ * tree — a port of the iOS SDK's `HTMLNode.swift` mapping that must stay in sync
+ * with it. See core/llm-docs/CLASSIC.md ("iOS DOM Synthesis").
+ */
+export type NativeElementNode = {
+    /** XCUIElementType case-name form, e.g. 'button', 'staticText', 'application'. */
+    elementType: string;
+    /** Element frame in points; origin is top-left. */
+    frame?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Accessibility label (iOS gives '' for unlabeled; the parser should map ''->undefined). */
+    label?: string;
+    /** Any pre-existing attributes (usually none from the Appium path). */
+    attributes?: Record<string, string>;
+    children?: NativeElementNode[];
+};
+type Rect = {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+};
+export type SyntheticDomNode = {
+    tagName: string;
+    attributes?: Record<string, string>;
+    childNodes: SyntheticDomNode[];
+    rect?: Rect;
+    rects?: Rect[];
+    text?: string;
+    version?: string;
+    source?: string;
+    metadata?: unknown;
+};
+export declare function synthesizeNativeDom(root: NativeElementNode, { source, version, metadata }?: {
+    source?: string;
+    version?: string;
+    metadata?: unknown;
+}): SyntheticDomNode;
+export {};

package/types/classic/utils/take-ios-dom-capture.d.ts

@@ -0,0 +1,13 @@
+import { type Logger } from '@applitools/logger';
+import { type SpecType, type Driver } from '@applitools/driver';
+/**
+ * iOS no-NML counterpart of `takeDomCapture`: reads the accessibility hierarchy
+ * through the driver and synthesizes an Applitools DOM document from it (see
+ * docs/native-dom-without-nml-design.md). Returns undefined — an image-only
+ * check — when the driver has no page source or synthesis fails; a DOM problem
+ * must never fail the check itself.
+ */
+export declare function takeIosDomCapture<TSpec extends SpecType>({ driver, logger, }: {
+    driver: Driver<TSpec>;
+    logger: Logger;
+}): Promise<string | undefined>;