@ts-for-gir/lib/lib/gir/enum.js

Typescript .d.ts generator from GIR for gjs

import { NumberType, TypeIdentifier } from "../gir.js";
import { IntrospectedBase, IntrospectedNamespaceMember } from "./base.js";
import { GirComplexRecord } from "./class.js";
import { IntrospectedField } from "./property.js";
import { IntrospectedStaticClassFunction } from "./function.js";
import { parseDoc, parseMetadata, sanitizeIdentifierName, sanitizeMemberName } from "./util.js";
export class IntrospectedEnum extends IntrospectedNamespaceMember {
    members = new Map();
    flags = false;
    ns;
    constructor(name, namespace, options = {}) {
        super(sanitizeIdentifierName(namespace.namespace, name), namespace, options);
        this.ns = namespace;
    }
    copy({ members } = {}) {
        const { namespace, name, flags } = this;
        const en = new IntrospectedEnum(name, namespace);
        for (const [key, member] of (members ?? this.members).entries()) {
            en.members.set(key, member.copy());
        }
        en.flags = flags;
        en._copyBaseProperties(this);
        return en;
    }
    accept(visitor) {
        const node = this.copy({
            members: new Map(Array.from(this.members.entries()).map(([name, m]) => {
                return [name, m.accept(visitor)];
            }))
        });
        return visitor.visitEnum?.(node) ?? node;
    }
    getType() {
        return new TypeIdentifier(this.name, this.ns.namespace);
    }
    asString(generator) {
        return generator.generateEnum(this);
    }
    asClass() {
        const { name, namespace, doc } = this;
        const clazz = new GirComplexRecord({ name, namespace, doc });
        clazz.fields.push(...Array.from(this.members.values()).map(m => {
            const field = new IntrospectedField({
                name: m.name,
                parent: clazz,
                type: NumberType,
                writable: true,
                isStatic: true
            });
            field.doc = m.doc;
            field.metadata = m.metadata;
            return field;
        }));
        clazz.members = [];
        return clazz;
    }
    static fromXML(element, ns, options, flags = false) {
        const em = new IntrospectedEnum(sanitizeMemberName(element.$.name), ns);
        if (element.$["glib:type-name"]) {
            em.resolve_names.push(element.$["glib:type-name"]);
            ns.registerResolveName(element.$["glib:type-name"], ns.namespace, em.name);
        }
        if (element.$["c:type"]) {
            em.resolve_names.push(element.$["c:type"]);
            ns.registerResolveName(element.$["c:type"], ns.namespace, em.name);
        }
        if (options.loadDocs) {
            em.doc = parseDoc(element);
            em.metadata = parseMetadata(element);
        }
        if (!element.member) {
            return em;
        }
        element.member.forEach(m => {
            const member = GirEnumMember.fromXML(m, em, options);
            em.members.set(member.name, member);
        });
        em.flags = flags;
        return em;
    }
}
export class GirEnumMember extends IntrospectedBase {
    value;
    c_identifier;
    constructor(name, value, parent, c_identifier) {
        super(name, parent);
        this.value = value;
        this.c_identifier = c_identifier;
    }
    get namespace() {
        return this.parent.namespace;
    }
    accept(visitor) {
        const node = this.copy();
        return visitor.visitEnumMember?.(node) ?? node;
    }
    copy() {
        const { value, name, parent, c_identifier } = this;
        return new GirEnumMember(name, value, parent, c_identifier)._copyBaseProperties(this);
    }
    static fromXML(element, parent, options) {
        const upper = element.$.name.toUpperCase();
        const c_identifier = element.$["c:identifier"];
        const enumMember = new GirEnumMember(upper, element.$.value, parent, c_identifier);
        if (options.loadDocs) {
            enumMember.doc = parseDoc(element);
            enumMember.metadata = parseMetadata(element);
        }
        return enumMember;
    }
    asString(generator) {
        return generator.generateEnumMember(this);
    }
}
function isEnumElement(e) {
    return typeof e === "object" && e != null && "function" in e;
}
export class IntrospectedError extends IntrospectedEnum {
    functions = new Map();
    asString(generator) {
        return generator.generateError(this);
    }
    copy({ members } = {}) {
        const { namespace, name, flags } = this;
        const en = new IntrospectedError(name, namespace);
        for (const [key, member] of (members ?? this.members).entries()) {
            en.members.set(key, member.copy());
        }
        for (const [key, func] of this.functions.entries()) {
            en.functions.set(key, func.copy({ parent: en }));
        }
        en.flags = flags;
        return en._copyBaseProperties(this);
    }
    static fromXML(element, ns, options) {
        const err = new IntrospectedError(sanitizeMemberName(element.$.name), ns);
        if (element.$["glib:type-name"]) {
            err.resolve_names.push(element.$["glib:type-name"]);
            ns.registerResolveName(element.$["glib:type-name"], ns.namespace, err.name);
        }
        if (element.$["c:type"]) {
            err.resolve_names.push(element.$["c:type"]);
            ns.registerResolveName(element.$["c:type"], ns.namespace, err.name);
        }
        if (options.loadDocs) {
            err.doc = parseDoc(element);
            err.metadata = parseMetadata(element);
        }
        if (element.member) {
            element.member.forEach(m => {
                const member = GirEnumMember.fromXML(m, err, options);
                err.members.set(member.name, member);
            });
        }
        if (isEnumElement(element) && element.function) {
            element.function.forEach(f => {
                const func = IntrospectedStaticClassFunction.fromXML(f, err, options);
                err.functions.set(func.name, func);
            });
        }
        return err;
    }
}
//# sourceMappingURL=enum.js.map