hennus-api/app/types/bitfield/index.js

Esta es una libreria para el bot Hennus

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BitField = void 0;
const Error_1 = require("../../core/Error");
class BitField {
    constructor(bits) {
        this.Flags = {};
        this.DefaultBit = 0;
        if (bits)
            this.bitfield = this.resolve(bits);
    }
    ;
    any(bit) {
        const resolvedBit = this.resolve(bit);
        const bitfield = this.bitfield;
        if (typeof bitfield === "bigint" && typeof resolvedBit === "bigint")
            return (bitfield & resolvedBit) !== BigInt(this.DefaultBit);
        else if (typeof bitfield === "number" && typeof resolvedBit === "number")
            return (bitfield & resolvedBit) !== this.DefaultBit;
        else
            return false;
    }
    ;
    equals(bit) {
        return this.bitfield === this.resolve(bit);
    }
    ;
    has(bit) {
        const resolvedBit = this.resolve(bit);
        const bitfield = this.bitfield;
        if (typeof bitfield === "bigint" && typeof resolvedBit === "bigint")
            return (bitfield & resolvedBit) === resolvedBit;
        else if (typeof bitfield === "number" && typeof resolvedBit === "number")
            return (bitfield & resolvedBit) === resolvedBit;
        else
            return false;
    }
    ;
    missing(bits, ...hasParams) {
        return new BitField(bits).remove(this).toArray(...hasParams);
    }
    ;
    freeze() {
        return Object.freeze(this);
    }
    ;
    add(...bits) {
        let total = this.DefaultBit;
        for (const bit of bits) {
            total = this.bitwiseOr(total, this.resolve(bit));
        }
        if (Object.isFrozen(this))
            return new BitField(this.bitwiseOr(this.bitfield, total));
        this.bitfield = this.bitwiseOr(this.bitfield, total);
        return this;
    }
    ;
    bitwiseOr(a, b) {
        if (typeof a === "bigint" && typeof b === "bigint")
            return (a | b);
        else if (typeof a === "number" && typeof b === "number")
            return (a | b);
        else
            return (Number(a) | Number(b));
    }
    ;
    remove(...bits) {
        let total = this.DefaultBit;
        for (const bit of bits) {
            total = this.bitwiseOr(total, this.resolve(bit));
        }
        if (Object.isFrozen(this))
            return new BitField(this.bitwiseAnd(this.bitfield, this.bitwiseNot(total)));
        this.bitfield = this.bitwiseAnd(this.bitfield, this.bitwiseNot(total));
        return this;
    }
    ;
    bitwiseAnd(a, b) {
        if (typeof a === "bigint" && typeof b === "bigint")
            return (a & b);
        else if (typeof a === "number" && typeof b === "number")
            return (a & b);
        else
            return (Number(a) & Number(b));
    }
    ;
    bitwiseNot(a) {
        if (typeof a === "bigint")
            return ~a;
        else if (typeof a === "number")
            return ~a;
        else
            return ~a;
    }
    ;
    serialize(...hasParams) {
        const serialized = {};
        const paramsArray = hasParams;
        for (const [flag, bit] of Object.entries(this.Flags)) {
            if (isNaN(parseFloat(flag))) {
                serialized[flag] = this.has(bit, ...paramsArray);
            }
        }
        return serialized;
    }
    ;
    toArray(...hasParams) {
        return [...this[Symbol.iterator](...hasParams)];
    }
    ;
    toJSON() {
        return typeof this.bitfield === 'number' ? this.bitfield : this.bitfield.toString();
    }
    ;
    valueOf() {
        return this.bitfield;
    }
    ;
    *[Symbol.iterator](...hasParams) {
        for (const bitName of Object.keys(this.Flags)) {
            if (isNaN(Number(bitName)) && this.has(bitName, ...hasParams))
                yield bitName;
        }
        ;
    }
    ;
    resolve(bit) {
        const DefaultBit = this.DefaultBit;
        if (typeof DefaultBit === typeof bit && bit >= DefaultBit)
            return bit;
        if (bit instanceof BitField)
            return bit.bitfield;
        if (Array.isArray(bit))
            return bit.map(p => this.resolve(p)).reduce((prev, p) => this.bitwiseOr(prev, p), DefaultBit);
        if (typeof bit === 'string') {
            if (!isNaN(Number(bit)))
                return typeof DefaultBit === 'bigint' ? BigInt(bit) : Number(bit);
            if (this.Flags[bit] !== undefined)
                return this.Flags[bit];
        }
        ;
        throw new Error_1.HennusError(Error_1.errorCodes.BitsError);
    }
    ;
}
exports.BitField = BitField;
;
__exportStar(require("./intentsbitfield"), exports);
__exportStar(require("./overwritesbitfields"), exports);
__exportStar(require("./permissions"), exports);
__exportStar(require("./flagsbifields"), exports);