@avimate/msfs-jest-utils 1.0.0

package/dist/mocks/SDKAdapter.js

@@ -0,0 +1,696 @@
+"use strict";
+/**
+ * SDK Adapter for Jest testing
+ *
+ * Provides mock implementations of MSFS SDK classes for testing.
+ * This allows components to be tested without the full SDK bundle.
+ *
+ * NOTE: We don't re-export types from @microsoft/msfs-types because
+ * they are declaration files and not modules. Types are resolved
+ * through TypeScript's type resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventBus = exports.SubscribableUtils = exports.MapSystemBuilder = exports.MapWxrModule = exports.MapOwnAirplanePropsModule = exports.MapOwnAirplaneIconModule = exports.MapIndexedRangeModule = exports.BingComponent = exports.MapProjection = exports.FacilityLoader = exports.FacilityRepository = exports.MapSystemKeys = exports.Vec2Subject = exports.Vec2Math = exports.NumberUnitSubject = exports.UnitType = exports.UnitTypeClass = exports.NumberUnit = exports.Subject = exports.FSComponent = exports.DisplayComponent = void 0;
+// Mock DisplayComponent
+class DisplayComponent {
+    constructor(props) {
+        this.props = props;
+    }
+    onAfterRender(vnode) {
+        // Default implementation - can be overridden
+    }
+    destroy() {
+        // Default implementation - can be overridden
+    }
+}
+exports.DisplayComponent = DisplayComponent;
+// Note: MSFSGlobals sets up FSComponent before this module is imported
+const globalFSComponent = globalThis.FSComponent;
+// Export the global FSComponent if available, otherwise use fallback
+// (This should not happen if setupTests.ts runs correctly)
+exports.FSComponent = globalFSComponent || {
+    buildComponent: (type, props, ...children) => {
+        // If it's a string (HTML/SVG tag), create a VNode structure
+        if (typeof type === 'string') {
+            const doc = globalThis.document;
+            if (!doc) {
+                return { type, props, children };
+            }
+            // Create actual DOM element
+            let element;
+            if (type === 'svg' || ['g', 'circle', 'text', 'line', 'polygon', 'path', 'rect', 'ellipse', 'polyline', 'defs', 'use', 'clipPath', 'mask', 'pattern', 'linearGradient', 'radialGradient', 'stop', 'filter', 'feGaussianBlur', 'feColorMatrix', 'feOffset', 'feMerge', 'feMergeNode'].includes(type)) {
+                element = doc.createElementNS('http://www.w3.org/2000/svg', type);
+            }
+            else {
+                element = doc.createElement(type);
+            }
+            // Handle ref first (before processing other props)
+            let ref = null;
+            if (props && props.ref) {
+                ref = props.ref;
+            }
+            // Apply props
+            if (props) {
+                Object.keys(props).forEach(key => {
+                    if (key === 'key' || key === 'ref') {
+                        // Skip these - ref is handled separately
+                        return;
+                    }
+                    const value = props[key];
+                    if (value === null || value === undefined) {
+                        return;
+                    }
+                    // For SVG elements, always use setAttribute
+                    if (element instanceof SVGElement) {
+                        // Style support (including Subscribable values)
+                        if (key === 'style' && typeof value === 'object') {
+                            Object.keys(value).forEach(styleKey => {
+                                const styleVal = value[styleKey];
+                                // Subscribable-like: has get/sub
+                                if (styleVal && typeof styleVal === 'object' && typeof styleVal.get === 'function' && typeof styleVal.sub === 'function') {
+                                    try {
+                                        element.style[styleKey] = String(styleVal.get());
+                                    }
+                                    catch { /* ignore */ }
+                                    styleVal.sub((v) => {
+                                        try {
+                                            element.style[styleKey] = String(v);
+                                        }
+                                        catch { /* ignore */ }
+                                    });
+                                }
+                                else {
+                                    try {
+                                        element.style[styleKey] = String(styleVal);
+                                    }
+                                    catch { /* ignore */ }
+                                }
+                            });
+                            return;
+                        }
+                        // Normalize className -> class for SVG
+                        if (key === 'className') {
+                            element.setAttribute('class', String(value));
+                            return;
+                        }
+                        if (key === 'class') {
+                            element.setAttribute('class', String(value));
+                            return;
+                        }
+                        // Normalize some common camelCase SVG attributes
+                        const svgAttrMap = {
+                            strokeWidth: 'stroke-width',
+                            fillRule: 'fill-rule',
+                            dominantBaseline: 'dominant-baseline',
+                            textAnchor: 'text-anchor',
+                        };
+                        const attrName = svgAttrMap[key] || key.replace(/([A-Z])/g, '-$1').toLowerCase();
+                        element.setAttribute(attrName, String(value));
+                    }
+                    else {
+                        // For HTML elements
+                        if (key === 'style' && typeof value === 'object') {
+                            Object.keys(value).forEach(styleKey => {
+                                const styleVal = value[styleKey];
+                                if (styleVal && typeof styleVal === 'object' && typeof styleVal.get === 'function' && typeof styleVal.sub === 'function') {
+                                    try {
+                                        element.style[styleKey] = String(styleVal.get());
+                                    }
+                                    catch { /* ignore */ }
+                                    styleVal.sub((v) => {
+                                        try {
+                                            element.style[styleKey] = String(v);
+                                        }
+                                        catch { /* ignore */ }
+                                    });
+                                }
+                                else {
+                                    try {
+                                        element.style[styleKey] = String(styleVal);
+                                    }
+                                    catch { /* ignore */ }
+                                }
+                            });
+                            return;
+                        }
+                        if (key === 'className') {
+                            element.className = String(value);
+                        }
+                        else if (key === 'class') {
+                            element.className = String(value);
+                        }
+                        else if (key.startsWith('data-')) {
+                            element.setAttribute(key, String(value));
+                        }
+                        else {
+                            // Try to set as property first, fallback to attribute
+                            try {
+                                element[key] = value;
+                            }
+                            catch {
+                                element.setAttribute(key, String(value));
+                            }
+                        }
+                    }
+                });
+            }
+            // Set ref.instance after element is created and props are applied
+            if (ref && typeof ref === 'object' && 'instance' in ref) {
+                ref.instance = element;
+            }
+            // Process children - recursively build VNodes into DOM nodes
+            // Children from JSX transformation are already VNodes (results of buildComponent calls)
+            const processChildren = (childList) => {
+                childList.forEach(child => {
+                    if (child === null || child === undefined) {
+                        return; // Skip JSX comments and null children
+                    }
+                    // String/number children become text nodes
+                    if (typeof child === 'string' || typeof child === 'number') {
+                        element.appendChild(doc.createTextNode(String(child)));
+                        return;
+                    }
+                    if (child && typeof child === 'object') {
+                        // If child is already a DOM Node, append directly
+                        if (child instanceof Node) {
+                            element.appendChild(child);
+                            return;
+                        }
+                        // If child is a VNode with an instance (already built), append the instance
+                        if (child.instance && child.instance instanceof Node) {
+                            element.appendChild(child.instance);
+                            return;
+                        }
+                        // If child is a VNode with a type, build it
+                        if (child.type) {
+                            // Extract children from VNode, filtering null/undefined (JSX comments)
+                            const vnodeChildren = [];
+                            if (Array.isArray(child.children)) {
+                                vnodeChildren.push(...child.children.filter((c) => c !== null && c !== undefined));
+                            }
+                            else if (child.children !== null && child.children !== undefined) {
+                                vnodeChildren.push(child.children);
+                            }
+                            // Build the child VNode - this will create the DOM element
+                            const built = exports.FSComponent.buildComponent(child.type, child.props || {}, ...vnodeChildren);
+                            // Append the built element's instance
+                            if (built && built.instance && built.instance instanceof Node) {
+                                element.appendChild(built.instance);
+                            }
+                            else if (built && built.type) {
+                                // If still a VNode, recursively process
+                                const processedChildren = [];
+                                if (Array.isArray(built.children)) {
+                                    processedChildren.push(...built.children.filter((c) => c !== null && c !== undefined));
+                                }
+                                else if (built.children !== null && built.children !== undefined) {
+                                    processedChildren.push(built.children);
+                                }
+                                const processed = exports.FSComponent.buildComponent(built.type, built.props || {}, ...processedChildren);
+                                if (processed && processed.instance && processed.instance instanceof Node) {
+                                    element.appendChild(processed.instance);
+                                }
+                            }
+                            return;
+                        }
+                        // If child is an array, process recursively
+                        if (Array.isArray(child)) {
+                            processChildren(child);
+                            return;
+                        }
+                    }
+                });
+            };
+            if (children && children.length > 0) {
+                processChildren(children);
+            }
+            return {
+                type,
+                props,
+                children,
+                instance: element
+            };
+        }
+        // If it's a function (component), instantiate it
+        if (typeof type === 'function') {
+            const component = new type(props);
+            // If a ref was provided, set it to the component instance (component refs).
+            if (props && props.ref && typeof props.ref === 'object' && 'instance' in props.ref) {
+                props.ref.instance = component;
+            }
+            const renderResult = component.render();
+            if (renderResult) {
+                return renderResult;
+            }
+            return { type, props, children, instance: null };
+        }
+        return { type, props, children };
+    },
+    render: (vnode, container) => {
+        if (!vnode)
+            return;
+        const targetDoc = container.ownerDocument || globalThis.document;
+        if (!targetDoc)
+            return;
+        // Helper to safely adopt or clone a node into the target document
+        const adoptOrCloneNode = (node) => {
+            // Check if node is already in the target document
+            if (node.ownerDocument === targetDoc) {
+                return node;
+            }
+            // Try to adopt the node (works in real browsers, may not work in jsdom)
+            try {
+                if (targetDoc.adoptNode) {
+                    return targetDoc.adoptNode(node);
+                }
+            }
+            catch (e) {
+                // If adoptNode fails, clone the node
+            }
+            // Clone the node and its children recursively
+            return node.cloneNode(true);
+        };
+        // Helper to safely append a node to a parent
+        const safeAppendChild = (parent, child) => {
+            try {
+                parent.appendChild(child);
+            }
+            catch (e) {
+                // If appendChild fails (e.g., cross-document issue), try to adopt/clone first
+                const adoptedChild = adoptOrCloneNode(child);
+                parent.appendChild(adoptedChild);
+            }
+        };
+        // Helper to re-establish refs after node manipulation
+        // This ensures refs point to the correct DOM nodes after cloning/adopting
+        const reestablishRefs = (vnode, domNode) => {
+            if (!vnode || !domNode)
+                return;
+            // Update VNode instance to point to the new DOM node
+            vnode.instance = domNode;
+            // If this VNode has a ref in props, update it to point to the DOM node
+            if (vnode.props && vnode.props.ref && typeof vnode.props.ref === 'object' && 'instance' in vnode.props.ref) {
+                vnode.props.ref.instance = domNode;
+            }
+            // Also check if the built VNode has refs that need updating
+            if (vnode.instance === domNode && vnode.props && vnode.props.ref) {
+                // This is the original instance, ref should already be set, but ensure it's correct
+                if (typeof vnode.props.ref === 'object' && 'instance' in vnode.props.ref) {
+                    vnode.props.ref.instance = domNode;
+                }
+            }
+            // Recursively process children - match VNode children with DOM child nodes
+            if (vnode.children && domNode instanceof Element) {
+                const childNodes = Array.from(domNode.childNodes).filter(n => n instanceof Element);
+                const vnodeChildren = Array.isArray(vnode.children)
+                    ? vnode.children.filter((c) => c && (c.type || c.instance))
+                    : (vnode.children && (vnode.children.type || vnode.children.instance) ? [vnode.children] : []);
+                // Match VNode children with DOM nodes by position
+                vnodeChildren.forEach((childVNode, vnodeIndex) => {
+                    if (!childVNode)
+                        return;
+                    // Find corresponding DOM node
+                    // For elements, try to match by type/position
+                    let domChild = null;
+                    if (childVNode.instance && childVNode.instance instanceof Node) {
+                        // VNode has an instance - find it in the DOM tree
+                        for (const node of childNodes) {
+                            if (node === childVNode.instance ||
+                                (node instanceof Element && childVNode.instance instanceof Element &&
+                                    node.tagName === childVNode.instance.tagName &&
+                                    node.getAttribute('id') === childVNode.instance.getAttribute('id'))) {
+                                domChild = node;
+                                break;
+                            }
+                        }
+                    }
+                    else if (vnodeIndex < childNodes.length) {
+                        // Fallback: match by position
+                        domChild = childNodes[vnodeIndex];
+                    }
+                    if (domChild) {
+                        reestablishRefs(childVNode, domChild);
+                    }
+                });
+            }
+        };
+        // Recursively build and render VNode tree
+        const renderVNode = (node) => {
+            if (!node)
+                return null;
+            // If it's already a DOM node, adopt/clone it
+            if (node instanceof Node) {
+                return adoptOrCloneNode(node);
+            }
+            // If it has an instance, adopt/clone it and re-establish refs
+            if (node.instance && node.instance instanceof Node) {
+                const adoptedNode = adoptOrCloneNode(node.instance);
+                reestablishRefs(node, adoptedNode);
+                return adoptedNode;
+            }
+            // If it's a string or number, create text node
+            if (typeof node === 'string' || typeof node === 'number') {
+                return targetDoc.createTextNode(String(node));
+            }
+            // If it's an array, process each element
+            if (Array.isArray(node)) {
+                const fragment = targetDoc.createDocumentFragment();
+                node.forEach(child => {
+                    const childNode = renderVNode(child);
+                    if (childNode) {
+                        safeAppendChild(fragment, childNode);
+                    }
+                });
+                return fragment;
+            }
+            // Build component from VNode
+            if (node.type) {
+                // If VNode already has an instance (from initial buildComponent), use it directly
+                // This preserves refs that were set during the initial build
+                if (node.instance && node.instance instanceof Node) {
+                    const adoptedNode = adoptOrCloneNode(node.instance);
+                    // Re-establish refs to point to the adopted/cloned node
+                    reestablishRefs(node, adoptedNode);
+                    return adoptedNode;
+                }
+                // Otherwise, build it fresh (shouldn't happen in normal flow, but handle it)
+                // Pass children directly to buildComponent - it will handle VNodes, Nodes, strings, etc.
+                // Filter out null/undefined (from JSX comments)
+                const children = (node.children || []).filter((child) => child !== null && child !== undefined);
+                const built = exports.FSComponent.buildComponent(node.type, node.props || {}, ...children);
+                // If built has instance, adopt/clone it and re-establish refs
+                if (built && built.instance && built.instance instanceof Node) {
+                    const adoptedNode = adoptOrCloneNode(built.instance);
+                    reestablishRefs(built, adoptedNode);
+                    return adoptedNode;
+                }
+                // If built is a VNode without instance, recursively process it
+                if (built && built.type && !built.instance) {
+                    return renderVNode(built);
+                }
+                // If built has children but no instance, process children into a fragment
+                if (built && built.children && Array.isArray(built.children)) {
+                    const fragment = targetDoc.createDocumentFragment();
+                    built.children.forEach((child) => {
+                        // If child is already a Node, append it
+                        if (child instanceof Node) {
+                            safeAppendChild(fragment, adoptOrCloneNode(child));
+                        }
+                        else {
+                            // Otherwise process as VNode
+                            const childNode = renderVNode(child);
+                            if (childNode) {
+                                safeAppendChild(fragment, childNode);
+                            }
+                        }
+                    });
+                    return fragment;
+                }
+            }
+            return null;
+        };
+        const rootNode = renderVNode(vnode);
+        if (rootNode) {
+            safeAppendChild(container, rootNode);
+            // Re-establish all refs in the tree after everything is in the DOM
+            // This ensures refs point to the final DOM nodes (after any cloning/adopting)
+            reestablishRefs(vnode, rootNode);
+        }
+    },
+    Fragment: (props, ...children) => {
+        return { type: 'Fragment', children };
+    },
+    createRef() {
+        return { instance: null };
+    },
+};
+// Mock Subject
+class Subject {
+    constructor(initialValue) {
+        this.subscribers = [];
+        this.value = initialValue;
+    }
+    static create(initialValue) {
+        return new Subject(initialValue);
+    }
+    get() {
+        return this.value;
+    }
+    set(value) {
+        this.value = value;
+        this.subscribers.forEach(sub => sub(value));
+    }
+    sub(callback, immediate = false) {
+        this.subscribers.push(callback);
+        if (immediate) {
+            callback(this.value);
+        }
+        return {
+            destroy: () => {
+                const index = this.subscribers.indexOf(callback);
+                if (index > -1) {
+                    this.subscribers.splice(index, 1);
+                }
+            }
+        };
+    }
+    /**
+     * Create a mapped Subscribable from this subject.
+     * Mimics MSFS SDK Subject.map() enough for UI binding tests.
+     */
+    map(fn, _equalityFunc) {
+        return new MappedSubscribable(this, fn);
+    }
+}
+exports.Subject = Subject;
+class MappedSubscribable {
+    constructor(source, fn) {
+        this.source = source;
+        this.fn = fn;
+    }
+    get() {
+        const next = this.fn(this.source.get(), this.prev);
+        this.prev = next;
+        return next;
+    }
+    sub(callback, immediate = false) {
+        const handle = this.source.sub((v) => {
+            const mapped = this.fn(v, this.prev);
+            this.prev = mapped;
+            callback(mapped);
+        }, immediate);
+        this.subHandle = handle;
+        return { destroy: () => handle.destroy() };
+    }
+    map(fn, _equalityFunc) {
+        return new MappedSubscribable(this, fn);
+    }
+    destroy() {
+        this.subHandle?.destroy();
+        this.subHandle = undefined;
+    }
+}
+class NumberUnit {
+    constructor(number, unit) {
+        this.number = number;
+        this.unit = unit;
+    }
+    asUnit(_unit) {
+        return this.number;
+    }
+}
+exports.NumberUnit = NumberUnit;
+class UnitTypeClass {
+    constructor(name) {
+        this.name = name;
+    }
+    createNumber(value) {
+        return new NumberUnit(value, this);
+    }
+}
+exports.UnitTypeClass = UnitTypeClass;
+exports.UnitType = {
+    NMILE: new UnitTypeClass('NMILE'),
+};
+exports.NumberUnitSubject = {
+    create: (initial) => Subject.create(initial),
+};
+exports.Vec2Math = {
+    create(x = 0, y = 0) {
+        return new Float64Array([x, y]);
+    }
+};
+exports.Vec2Subject = {
+    create: (initial) => Subject.create(initial),
+};
+// -----------------------------
+// Map-system stubs (msfs-sdk side)
+// -----------------------------
+exports.MapSystemKeys = {
+    FacilityLoader: 'FacilityLoader',
+    Weather: 'Weather',
+    OwnAirplaneIcon: 'OwnAirplaneIcon',
+};
+class FacilityRepository {
+    static getRepository(_bus) {
+        return {};
+    }
+}
+exports.FacilityRepository = FacilityRepository;
+class FacilityLoader {
+    constructor(_repo) { }
+}
+exports.FacilityLoader = FacilityLoader;
+class MapProjection {
+    project(_lla, out) {
+        out[0] = 0.5;
+        out[1] = 0.5;
+        return out;
+    }
+}
+exports.MapProjection = MapProjection;
+class BingComponent {
+    static createEarthColorsArray(_waterColor, _stops, _a, _b, _c) {
+        return [];
+    }
+}
+exports.BingComponent = BingComponent;
+class MapIndexedRangeModule {
+    constructor() {
+        this.nominalRange = Subject.create(exports.UnitType.NMILE.createNumber(100));
+    }
+}
+exports.MapIndexedRangeModule = MapIndexedRangeModule;
+class MapOwnAirplaneIconModule {
+}
+exports.MapOwnAirplaneIconModule = MapOwnAirplaneIconModule;
+class MapOwnAirplanePropsModule {
+}
+exports.MapOwnAirplanePropsModule = MapOwnAirplanePropsModule;
+class MapWxrModule {
+}
+exports.MapWxrModule = MapWxrModule;
+class MockMapContext {
+    constructor(bus, _modules, _controllers) {
+        this.bus = bus;
+        this._modules = _modules;
+        this._controllers = _controllers;
+        this.model = {
+            getModule: (key) => {
+                var _d;
+                return ((_d = this._modules)[key] ?? (_d[key] = {}));
+            },
+        };
+        this.projection = new MapProjection();
+        this.projectionChanged = Subject.create(undefined);
+        this.bingRef = { instance: { setWxrColors: (_) => { }, wxrColors: Subject.create([]) } };
+    }
+    getController(key) {
+        return this._controllers[key];
+    }
+}
+class MockMapSystemBuilder {
+    constructor(bus) {
+        this.bus = bus;
+        this.modules = {};
+        this.controllers = {};
+        this.rangeValues = [];
+        this._inits = [];
+    }
+    withContext(_key, _factory) { return this; }
+    withModule(key, factory) {
+        // create module instance eagerly
+        this.modules[String(key)] = factory();
+        return this;
+    }
+    with(_token, maybeRangeArray) {
+        // Special-case range arrays: passed as second arg by StormScopeMapManager via GarminMapBuilder.range
+        if (Array.isArray(maybeRangeArray)) {
+            this.rangeValues = maybeRangeArray;
+            // ensure Range module has nominalRange
+            if (!this.modules['Range']) {
+                this.modules['Range'] = new MapIndexedRangeModule();
+            }
+        }
+        return this;
+    }
+    withInit(_name, init) {
+        // run init later at build time
+        this._inits.push(init);
+        return this;
+    }
+    withBing(_bingId, _opts) { return this; }
+    withOwnAirplanePropBindings(_bindings, _hz) { return this; }
+    withFollowAirplane() { return this; }
+    withController(key, factory) {
+        this.controllers[String(key)] = factory({ model: this.modules, bus: this.bus });
+        return this;
+    }
+    withProjectedSize(_size) { return this; }
+    build(mapId) {
+        // Ensure Range module shape expected by StormScopeMapManager
+        if (!this.modules['Range']) {
+            this.modules['Range'] = new MapIndexedRangeModule();
+        }
+        const rangeModule = this.modules['Range'];
+        if (rangeModule && !rangeModule.nominalRange) {
+            rangeModule.nominalRange = Subject.create(exports.UnitType.NMILE.createNumber(100));
+        }
+        // Provide a default Range controller if not present
+        if (!this.controllers['Range']) {
+            // Lazy require to avoid circular import
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                const { MapRangeController } = require('@microsoft/msfs-garminsdk');
+                this.controllers['Range'] = new MapRangeController(this.rangeValues, rangeModule.nominalRange);
+            }
+            catch {
+                this.controllers['Range'] = { changeRangeIndex: () => { }, setRangeIndex: () => { } };
+            }
+        }
+        const context = new MockMapContext(this.bus, this.modules, this.controllers);
+        // Run init hooks with a context-like object
+        this._inits.forEach(fn => {
+            try {
+                fn({ bus: this.bus, model: { getModule: (k) => this.modules[String(k)] }, getController: (k) => this.controllers[String(k)], ...context });
+            }
+            catch { /* ignore */ }
+        });
+        const mapVNode = exports.FSComponent.buildComponent('div', { id: mapId, class: 'stormscope-map' });
+        const ref = { instance: { update: (_t) => { }, wake: () => { }, sleep: () => { } } };
+        return { context, map: mapVNode, ref };
+    }
+}
+exports.MapSystemBuilder = {
+    create: (bus) => new MockMapSystemBuilder(bus),
+};
+// Utility namespace placeholder used by some code imports
+exports.SubscribableUtils = {};
+// Mock EventBus
+class EventBus {
+    constructor() {
+        this.events = new Map();
+    }
+    on(topic, callback) {
+        if (!this.events.has(topic)) {
+            this.events.set(topic, []);
+        }
+        this.events.get(topic).push(callback);
+    }
+    off(topic, callback) {
+        const callbacks = this.events.get(topic);
+        if (callbacks) {
+            const index = callbacks.indexOf(callback);
+            if (index > -1) {
+                callbacks.splice(index, 1);
+            }
+        }
+    }
+    pub(topic, data) {
+        const callbacks = this.events.get(topic);
+        if (callbacks) {
+            callbacks.forEach(cb => cb(data));
+        }
+    }
+}
+exports.EventBus = EventBus;