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

Typescript .d.ts generator from GIR for gjs

import { VoidType, UnknownType, NativeType, ThisType, NumberType, NullableType, ArrayType } from "../gir.js";
import { IntrospectedClassMember } from "./base.js";
import { isIntrospectable } from "./namespace.js";
import { IntrospectedClassFunction, IntrospectedFunctionParameter, IntrospectedClassCallback } from "./function.js";
import { GirDirection } from "@gi.ts/parser";
import { getType, parseDoc, parseMetadata } from "./util.js";
export var IntrospectedSignalType;
(function (IntrospectedSignalType) {
    IntrospectedSignalType[IntrospectedSignalType["CONNECT"] = 0] = "CONNECT";
    IntrospectedSignalType[IntrospectedSignalType["CONNECT_AFTER"] = 1] = "CONNECT_AFTER";
    IntrospectedSignalType[IntrospectedSignalType["EMIT"] = 2] = "EMIT";
})(IntrospectedSignalType || (IntrospectedSignalType = {}));
export class IntrospectedSignal extends IntrospectedClassMember {
    parameters;
    return_type;
    detailed;
    constructor({ name, parameters = [], return_type = UnknownType, detailed = false, parent, ...args }) {
        super(name, parent, { ...args });
        this.parameters = parameters.map(p => p.copy({ parent: this }));
        this.return_type = return_type;
        this.detailed = detailed;
    }
    accept(visitor) {
        const node = this.copy({
            parameters: this.parameters.map(p => {
                return p.accept(visitor);
            }),
            returnType: visitor.visitType?.(this.return_type)
        });
        return visitor.visitSignal?.(node) ?? node;
    }
    copy({ parent = this.parent, parameters, returnType, detailed } = {}) {
        return new IntrospectedSignal({
            name: this.name,
            parent,
            parameters: parameters ?? this.parameters,
            return_type: returnType ?? this.return_type,
            detailed: detailed ?? this.detailed
        })._copyBaseProperties(this);
    }
    static fromXML(element, parent, options) {
        const ns = parent.namespace;
        const signal = new IntrospectedSignal({
            name: element.$.name,
            parent,
            detailed: element.$.detailed === "1",
            isIntrospectable: isIntrospectable(element)
        });
        if (element.parameters && element.parameters[0].parameter) {
            signal.parameters.push(...element.parameters[0].parameter
                .filter((p) => !!p.$.name)
                .map(p => IntrospectedFunctionParameter.fromXML(p, signal, options)));
        }
        const length_params = [];
        signal.parameters = signal.parameters
            .map(p => {
            const unwrapped_type = p.type.unwrap();
            if (unwrapped_type instanceof ArrayType && unwrapped_type.length != null) {
                length_params.push(unwrapped_type.length);
                return p;
            }
            return p;
        })
            .filter((_, i) => {
            // We remove any length parameters.
            return !length_params.includes(i);
        })
            .reverse()
            .reduce(({ allowOptions, params }, p) => {
            const { type, isOptional } = p;
            if (allowOptions) {
                if (type instanceof NullableType) {
                    params.push(p.copy({ isOptional: true }));
                }
                else if (!isOptional) {
                    params.push(p);
                    return { allowOptions: false, params };
                }
                else {
                    params.push(p);
                }
            }
            else {
                if (isOptional) {
                    params.push(p.copy({ type: new NullableType(type), isOptional: false }));
                }
                else {
                    params.push(p);
                }
            }
            return { allowOptions, params };
        }, {
            allowOptions: true,
            params: []
        })
            .params.reverse()
            .filter((p) => p != null);
        signal.return_type = getType(ns, element["return-value"]?.[0]);
        if (options.loadDocs) {
            signal.doc = parseDoc(element);
            signal.metadata = parseMetadata(element);
        }
        return signal;
    }
    asEmit() {
        const emit = this.copy();
        const parent = this.parent;
        const prefix_signal = emit.parameters.some(p => {
            return p.name === "signal";
        });
        const parameters = [
            new IntrospectedFunctionParameter({
                name: prefix_signal ? "$signal" : "signal",
                type: NativeType.of(`'${this.name}'`),
                direction: GirDirection.In
            }),
            ...emit.parameters
        ];
        const return_type = VoidType;
        return new IntrospectedClassFunction({
            return_type,
            parameters,
            name: "emit",
            parent
        });
    }
    asConnect(after = false) {
        const connect = this.copy();
        const name = after ? "connect_after" : "connect";
        const parent = this.parent;
        const cb = new IntrospectedClassCallback({
            parent,
            name: "callback",
            output_parameters: [],
            parameters: [
                new IntrospectedFunctionParameter({
                    name: "_source",
                    type: ThisType,
                    direction: GirDirection.In
                }),
                ...connect.parameters.map(p => p.copy())
            ],
            return_type: connect.return_type
        });
        const parameters = [
            new IntrospectedFunctionParameter({
                name: "signal",
                type: NativeType.of(`'${this.name}'`),
                direction: GirDirection.In
            }),
            new IntrospectedFunctionParameter({
                name: "callback",
                type: cb.asFunctionType(),
                direction: GirDirection.In
            })
        ];
        const return_type = NumberType;
        return new IntrospectedClassFunction({
            return_type,
            parameters,
            name,
            parent: this.parent
        });
    }
    asString(generator, type) {
        return generator.generateSignal(this, type);
    }
}
//# sourceMappingURL=signal.js.map