Wand-Enhancer-k1tbyte/web-panel/bridge/scripts/default/installed-apps-sync/runtime.js

import { CONTAINER_GRAPH_MAX_DEPTH } from './constants.js';

export function isRecord(value) {
    return typeof value === 'object' && value !== null;
}

export function formatError(error) {
    return error?.stack || String(error);
}

export async function invokeIpc(state, channel, payload, label, level = 'warn') {
    if (!state.ipcRenderer) {
        return false;
    }

    try {
        await state.ipcRenderer.invoke(channel, payload);
        return true;
    } catch (error) {
        state.log(level, `${label} IPC failed.`, formatError(error));
        return false;
    }
}

export function isDiagnosticsDebugEnabled() {
    return globalThis.__wandInstalledAppsSyncDebug === true;
}

let lastPredicateErrorLogAt = 0;

function logContainerGraphPredicateError(error) {
    if (!isDiagnosticsDebugEnabled()) {
        return;
    }

    const now = Date.now();
    if (now - lastPredicateErrorLogAt < 1000) {
        return;
    }

    lastPredicateErrorLogAt = now;
    console.debug('[wand-installed-apps-sync] container graph predicate threw', formatError(error));
}

export function getRequire() {
    return globalThis.require || (typeof window !== 'undefined' ? window.require : null);
}

export function safeString(...values) {
    for (const value of values) {
        if (typeof value === 'string' && value.trim()) {
            return value.trim();
        }
    }

    return '';
}

export function getWebpackRequire() {
    const chunk = globalThis.webpackChunkWeMod;
    if (!Array.isArray(chunk)) {
        return null;
    }

    if (typeof chunk.__wandWebpackRequire === 'function') {
        return chunk.__wandWebpackRequire;
    }

    let resolvedRequire = null;
    chunk.push([
        [`wand-enhancer-${Date.now()}`],
        {},
        (webpackRequire) => {
            resolvedRequire = webpackRequire;
        },
    ]);

    if (typeof resolvedRequire === 'function') {
        chunk.__wandWebpackRequire = resolvedRequire;
    }

    return resolvedRequire;
}

export function getAppRoot() {
    return (
        document.getElementById('root') ||
        document.querySelector('[aurelia-app]') ||
        document.querySelector('root')
    );
}

export function hasAppRoot() {
    return Boolean(getAppRoot());
}

let cachedAureliaContainer = null;

function isUsableContainer(container) {
    return isRecord(container) && typeof container.get === 'function';
}

export function getAureliaContainer() {
    if (isUsableContainer(cachedAureliaContainer)) {
        return cachedAureliaContainer;
    }

    const resolved = resolveAureliaContainer();
    if (resolved) {
        cachedAureliaContainer = resolved;
    }

    return resolved;
}

function resolveAureliaContainer() {
    const root = getAppRoot();
    const rootContainer = getContainerFromSubtree(root);
    if (rootContainer) {
        return rootContainer;
    }

    const bodyContainer = getContainerFromElement(document.body);
    if (bodyContainer) {
        return bodyContainer;
    }

    if (isRecord(globalThis.aurelia) && globalThis.aurelia.container) {
        return globalThis.aurelia.container;
    }

    return null;
}

export function summarizeAureliaSubtree(root) {
    if (!isDiagnosticsDebugEnabled()) {
        return '(debug-disabled)';
    }

    if (!root) {
        return 'root=null';
    }

    let elementsWithAu = 0;
    let controllerEntries = 0;
    let namedAuEntries = 0;

    function inspectElement(element) {
        if (!isRecord(element?.au)) {
            return;
        }

        elementsWithAu += 1;

        if (element.au.controller) {
            controllerEntries += 1;
        }

        for (const [key, value] of Object.entries(element.au)) {
            if (key !== 'controller' && isRecord(value)) {
                namedAuEntries += 1;
            }
        }
    }

    inspectElement(root);

    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
    let element = walker.nextNode();
    while (element) {
        inspectElement(element);
        element = walker.nextNode();
    }

    return `elementsWithAu=${elementsWithAu}, controllerEntries=${controllerEntries}, namedAuEntries=${namedAuEntries}`;
}

export function findExportedConstructor(webpackRequire, predicate) {
    const cache = webpackRequire?.c;
    if (!cache || typeof cache !== 'object') {
        return null;
    }

    for (const record of Object.values(cache)) {
        const exports = record?.exports;
        const candidates = [];

        if (typeof exports === 'function') {
            candidates.push(exports);
        } else if (isRecord(exports)) {
            if (typeof exports.default === 'function') {
                candidates.push(exports.default);
            }

            for (const value of Object.values(exports)) {
                if (typeof value === 'function') {
                    candidates.push(value);
                }
            }
        }

        for (const candidate of candidates) {
            if (candidate?.prototype && predicate(candidate.prototype)) {
                return candidate;
            }
        }
    }

    return null;
}

export function findInstanceInContainerGraph(
    root,
    predicate,
    maxDepth = CONTAINER_GRAPH_MAX_DEPTH,
) {
    if (!root) {
        return null;
    }

    const seen = new Set();
    const queue = [{ value: root, depth: 0 }];

    while (queue.length > 0) {
        const current = queue.shift();
        const value = current?.value;
        const depth = current?.depth ?? 0;
        if (!value || seen.has(value)) {
            continue;
        }

        seen.add(value);

        try {
            if (predicate(value)) {
                return value;
            }
        } catch (error) {
            logContainerGraphPredicateError(error);
        }

        if (depth >= maxDepth) {
            continue;
        }

        enqueueNestedValues(queue, seen, value, depth + 1);
    }

    return null;
}

export function getBasename(location) {
    if (typeof location !== 'string' || !location.trim()) {
        return '';
    }

    const normalized = location.replace(/\\/g, '/').replace(/\/+$/, '');
    const leaf = normalized.split('/').filter(Boolean).pop();
    return leaf ? leaf.trim() : '';
}

export function toStringId(value) {
    if (typeof value === 'string' && value.trim()) {
        return value.trim();
    }

    if (typeof value === 'number' && Number.isFinite(value)) {
        return String(value);
    }

    return null;
}

export function normalizeStringList(value) {
    if (!Array.isArray(value)) {
        return [];
    }

    return value
        .filter((entry) => typeof entry === 'string' && entry.trim())
        .map((entry) => entry.trim());
}

export function getPreferredLocale() {
    return safeString(
        document.documentElement?.lang,
        Array.isArray(globalThis.navigator?.languages)
            ? globalThis.navigator.languages.find(
                  (entry) => typeof entry === 'string' && entry.trim(),
              )
            : '',
        globalThis.navigator?.language,
        'en-US',
    );
}

function getContainerFromAu(au) {
    if (!isRecord(au)) {
        return null;
    }

    if (au.container) {
        return au.container;
    }

    const directControllerContainer =
        au.controller?.container || au.controller?.viewModel?.container;
    if (directControllerContainer) {
        return directControllerContainer;
    }

    for (const value of Object.values(au)) {
        if (!isRecord(value)) {
            continue;
        }

        const container =
            value.container ||
            value.controller?.container ||
            value.viewModel?.container ||
            value.controller?.viewModel?.container;
        if (container) {
            return container;
        }
    }

    return null;
}

function getContainerFromElement(element) {
    if (!element) {
        return null;
    }

    if (element.__aurelia__?.container) {
        return element.__aurelia__.container;
    }

    return getContainerFromAu(element.au);
}

function getContainerFromSubtree(root) {
    if (!root) {
        return null;
    }

    const rootContainer = getContainerFromElement(root);
    if (rootContainer) {
        return rootContainer;
    }

    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
    let element = walker.nextNode();
    while (element) {
        const container = getContainerFromElement(element);
        if (container) {
            return container;
        }

        element = walker.nextNode();
    }

    return null;
}

function enqueueNestedValues(queue, seen, value, depth) {
    if (value instanceof Map) {
        enqueueIterable(queue, seen, value.values(), depth);
        return;
    }

    if (value instanceof Set || Array.isArray(value)) {
        enqueueIterable(queue, seen, value.values(), depth);
        return;
    }

    if (!isRecord(value) && typeof value !== 'function') {
        return;
    }

    enqueueIterable(queue, seen, Object.values(value), depth);
}

function enqueueIterable(queue, seen, values, depth) {
    for (const entry of values) {
        if ((isRecord(entry) || typeof entry === 'function') && !seen.has(entry)) {
            queue.push({ value: entry, depth });
        }
    }
}