@slightning/anything-to-string/dist/cjs/rules/anything.js

Converts anything to a string.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AnythingRule = void 0;
const _1 = require(".");
class AnythingRule {
    test(__data) {
        return true;
    }
    prepare(data, config, context) {
        var _a;
        const refCount = context.prepareData.refMap.get(data);
        if (refCount != undefined) {
            return;
        }
        if (context.accessedSet.has(data)) {
            if (data != null && typeof data == "object" &&
                (config.ref || context.pathArray.includes(data))) {
                context.prepareData.refMap.set(data, context.prepareData.refMap.size + 1);
                return;
            }
        }
        context.accessedSet.add(data);
        context.pathArray.push(data);
        if (config.depth <= 0 || context.pathArray.length <= config.depth) {
            let rules;
            if (typeof config.rules == "function") {
                rules = config.rules(data, config, context);
            }
            else {
                rules = config.rules;
            }
            for (const role of rules) {
                if (role.test(data)) {
                    (_a = role.prepare) === null || _a === void 0 ? void 0 : _a.call(role, data, config, context);
                    break;
                }
            }
        }
        context.pathArray.pop();
    }
    toString(data, config, context) {
        let result = "";
        const refCount = context.prepareData.refMap.get(data);
        if (refCount != undefined) {
            if (context.accessedRefSet.has(data)) {
                return `[Circular *${refCount}]`;
            }
            else {
                context.accessedRefSet.add(data);
                result += `<ref *${refCount}> `;
            }
        }
        context.depth++;
        let rules;
        if (config.depth <= 0 || context.depth <= config.depth) {
            if (typeof config.rules == "function") {
                rules = config.rules(data, config, context);
            }
            else {
                rules = config.rules;
            }
        }
        else {
            rules = _1.MINIMUM;
        }
        const role = rules.find((role) => role.test(data));
        if (role == undefined) {
            result += `[unknown type: ${typeof data} ${Object.prototype.toString.call(data)}]`;
        }
        else {
            result += role.toString(data, config, context);
        }
        context.depth--;
        return result;
    }
}
exports.AnythingRule = AnythingRule;