@ts-for-gir/lib 4.0.0-beta.25 → 4.0.0-beta.26

package/lib/generators/dts.js

@@ -1,683 +0,0 @@
-import { FormatGenerator } from "./generator.js";
-import { IntrospectedInterface, filterConflicts, filterFunctionConflict, FilterBehavior } from "../gir/class.js";
-import { promisifyFunctions } from "../gir/promisify.js";
-import { IntrospectedSignalType } from "../gir/signal.js";
-import { IntrospectedConstructor, IntrospectedFunctionParameter } from "../gir/function.js";
-import { IntrospectedClassFunction, IntrospectedStaticClassFunction } from "../gir/function.js";
-import { sanitizeIdentifierName, isInvalid, resolveDirectedType } from "../gir/util.js";
-import { NativeType, AnyType, VoidType, StringType, NumberType, ArrayType, AnyFunctionType, ConflictType, TypeConflict, BinaryType } from "../gir.js";
-import { GirDirection } from "@gi.ts/parser";
-export function versionImportFormat(versionFormat, namespace, version) {
-    const versionSlug = version.toLowerCase().split(".")[0];
-    const namespaceLowercase = namespace.toLowerCase();
-    return `${versionFormat
-        .replace("{version}", version)
-        .replace("{version-slug}", versionSlug)
-        .replace("{namespace}", namespace)
-        .replace("{namespace-lower}", namespaceLowercase)}`;
-}
-export class DtsGenerator extends FormatGenerator {
-    constructor(namespace, options) {
-        super(namespace, options);
-    }
-    generateParameters(parameters) {
-        return parameters
-            .map(p => {
-            return p.asString(this);
-        })
-            .join(", ");
-    }
-    generateGenerics(nodes, withDefaults = true) {
-        const { namespace, options } = this;
-        const list = nodes.map(generic => {
-            const Type = generic.type.rootPrint(namespace, options);
-            if (generic.defaultType && withDefaults) {
-                const defaultType = generic.defaultType.rootPrint(namespace, options);
-                if (generic.constraint) {
-                    const constraint = generic.constraint.rootPrint(namespace, options);
-                    return `${Type} extends ${constraint} = ${defaultType}`;
-                }
-                return `${Type} = ${defaultType}`;
-            }
-            else if (generic.constraint && withDefaults) {
-                const constraint = generic.constraint.rootPrint(namespace, options);
-                return `${Type} extends ${constraint}`;
-            }
-            else {
-                return `${Type}`;
-            }
-        });
-        if (list.length > 0) {
-            return `<${list.join(", ")}>`;
-        }
-        return "";
-    }
-    generateCallbackType(node) {
-        const { namespace, options } = this;
-        const Parameters = this.generateParameters(node.parameters);
-        if (node.generics.length > 0) {
-            const GenericDefinitions = this.generateGenerics(node.generics);
-            return [
-                `${GenericDefinitions}`,
-                `(${Parameters}) => ${node.return().resolve(namespace, options).print(namespace, options)}`
-            ];
-        }
-        return ["", `(${Parameters}) => ${node.return().resolve(namespace, options).print(namespace, options)}`];
-    }
-    generateCallback(node) {
-        return `${this.docString(node)}export type ${node.name}${this.generateCallbackType(node).join(" = ")};`;
-    }
-    generateClassCallback(node) {
-        return this.generateCallback(node);
-    }
-    generateReturn(return_type, output_parameters) {
-        const { namespace, options } = this;
-        const resolved_return_type = resolveDirectedType(return_type, GirDirection.Out)?.resolve(namespace, options) ??
-            return_type.resolve(namespace, options);
-        const type = resolved_return_type.rootPrint(namespace, options);
-        if (output_parameters.length > 0) {
-            const exclude_first = type === "void" || type === "";
-            const returns = [
-                ...(exclude_first ? [] : [`${type}`]),
-                ...output_parameters
-                    .map(op => {
-                    return (resolveDirectedType(op.type, GirDirection.Out)?.resolve(namespace, options) ??
-                        op.type.resolve(namespace, options));
-                })
-                    .map(p => p.rootPrint(namespace, options))
-            ];
-            if (returns.length > 1) {
-                return `[${returns.join(", ")}]`;
-            }
-            else {
-                return `${returns[0]}`;
-            }
-        }
-        return type;
-    }
-    generateEnum(node) {
-        const { namespace } = this;
-        const isInvalidEnum = Array.from(node.members.keys()).some(name => name.match(/^[0-9]+$/) || name === "NaN" || name === "Infinity");
-        if (isInvalidEnum) {
-            return node.asClass().asString(this);
-        }
-        // So we can use GObject.GType
-        this.namespace.assertInstalledImport("GObject");
-        return `
-export namespace ${node.name} {
-    export const $gtype: ${namespace.namespace !== "GObject" ? "GObject." : ""}GType<${node.name}>;
-}
-
-${this.docString(node)}export enum ${node.name} {
-    ${Array.from(node.members.values())
-            .map(member => `${member.asString(this)}`)
-            .join("\n    ")}
-}`;
-    }
-    generateError(node) {
-        const { namespace } = this;
-        const clazz = node.asClass();
-        clazz.members = [];
-        clazz.members.push(...Array.from(node.functions.values()));
-        const GLib = namespace.assertInstalledImport("GLib");
-        const GLibError = GLib.assertClass("Error");
-        clazz.superType = GLibError.getType();
-        // Manually construct a GLib.Error constructor.
-        clazz.mainConstructor = new IntrospectedConstructor({
-            name: "new",
-            parent: clazz,
-            parameters: [
-                new IntrospectedFunctionParameter({
-                    name: "options",
-                    type: NativeType.of("{ message: string, code: number}"),
-                    direction: GirDirection.In
-                })
-            ],
-            return_type: clazz.getType()
-        });
-        return clazz.asString(this);
-    }
-    generateConst(node) {
-        const { namespace, options } = this;
-        return `${this.docString(node)}export const ${node.name}: ${node.type
-            .resolve(namespace, options)
-            .print(namespace, options)};`;
-    }
-    implements(node) {
-        const { namespace, options } = this;
-        const interfaces = node.interfaces.map(i => {
-            const identifier = i.resolveIdentifier(namespace, options);
-            if (!identifier) {
-                throw new Error(`Unable to resolve type: ${i.name} from ${i.namespace} in ${node.namespace.namespace} ${node.namespace.version}`);
-            }
-            return identifier;
-        });
-        if (interfaces.length > 0) {
-            return ` implements ${interfaces
-                .map(i => {
-                const Type = i.print(namespace, options);
-                return `${Type}`;
-            })
-                .join(", ")}`;
-        }
-        return "";
-    }
-    extends(node) {
-        const { namespace: ns, options } = this;
-        if (node.superType) {
-            const ResolvedType = node.superType.resolveIdentifier(ns, options);
-            const Type = ResolvedType?.print(ns, options);
-            if (Type) {
-                return ` extends ${Type}`;
-            }
-            throw new Error(`Unable to resolve type: ${node.superType.name} from ${node.superType.namespace} in ${node.namespace.namespace} ${node.namespace.version}`);
-        }
-        return "";
-    }
-    generateInterface(node) {
-        const { namespace, options } = this;
-        const isGObject = node.someParent(p => p.namespace.namespace === "GObject" && p.name === "Object");
-        const name = node.name;
-        const generics = node.generics;
-        let Generics = "";
-        let GenericTypes = "";
-        if (generics.length > 0) {
-            Generics = `${this.generateGenerics(generics)}`;
-            GenericTypes = `${this.generateGenerics(generics, false)}`;
-        }
-        const Extends = this.extends(node);
-        const filteredFunctions = filterFunctionConflict(node.namespace, node, node.members, []);
-        const functions = options.promisify ? promisifyFunctions(filteredFunctions) : filteredFunctions;
-        const staticFunctions = functions.filter(f => f instanceof IntrospectedStaticClassFunction);
-        const staticFields = node.fields
-            .filter(f => f.isStatic)
-            .map(f => f.copy({
-            isStatic: false
-        }));
-        const nonStaticFunctions = functions.filter(f => !(f instanceof IntrospectedStaticClassFunction));
-        const nonStaticFields = node.fields.filter(f => !f.isStatic);
-        const hasNamespace = isGObject || staticFunctions.length > 0 || node.callbacks.length > 0;
-        if (isGObject) {
-            // So we can use GObject.GType
-            this.namespace.assertInstalledImport("GObject");
-        }
-        return `
-        ${node.callbacks.length > 0
-            ? `export module ${name} {
-  ${node.callbacks.map(c => c.asString(this)).join("\n")}
-  }`
-            : ""}
-      ${hasNamespace
-            ? `${this.docString(node)}export interface ${name}Namespace {
-    ${isGObject ? `$gtype: ${namespace.namespace !== "GObject" ? "GObject." : ""}GType<${name}>;` : ""}
-    prototype: ${name}Prototype;
-    ${staticFields.length > 0 ? staticFields.map(sf => sf.asString(this)).join("\n") : ""}
-    ${staticFunctions.length > 0
-                ? staticFunctions.map(sf => IntrospectedClassFunction.prototype.asString.call(sf, this)).join("\n")
-                : ""}    
-    }`
-            : ""}
-export type ${name}${Generics} = ${name}Prototype${GenericTypes};
-export interface ${name}Prototype${Generics}${Extends} {${node.__ts__indexSignature ? `\n${node.__ts__indexSignature}\n` : ""}
-    ${node.props.length > 0 ? "// Properties" : ""}
-    ${filterConflicts(node.namespace, node, node.props)
-            .map(p => p.asString(this))
-            .join("\n")}
-    ${nonStaticFields.length > 0 ? "// Fields" : ""}
-    ${filterConflicts(node.namespace, node, nonStaticFields)
-            .map(p => p.asString(this))
-            .join("\n")}
-    ${nonStaticFunctions.length > 0 ? "// Members\n" : ""}
-    ${nonStaticFunctions.map(m => m.asString(this)).join("\n")}
-    }${hasNamespace ? `\n\nexport const ${name}: ${name}Namespace;\n` : ""}`;
-    }
-    generateRecord(node) {
-        const { options, namespace } = this;
-        const { name } = node;
-        const Extends = this.extends(node);
-        let Generics = "";
-        if (node.generics.length > 0) {
-            Generics = `${this.generateGenerics(node.generics)}`;
-        }
-        let MainConstructor = "";
-        if (node.isForeign()) {
-            MainConstructor = "";
-        }
-        else if (node.mainConstructor) {
-            MainConstructor = node.mainConstructor.asString(this);
-        }
-        const hasCallbacks = node.callbacks.length > 0;
-        const Properties = filterConflicts(node.namespace, node, node.props)
-            .map(v => v.asString(this))
-            .join("\n");
-        const Fields = filterConflicts(node.namespace, node, node.fields)
-            .map(v => v.asString(this))
-            .join("\n");
-        const Constructors = filterConflicts(node.namespace, node, node.constructors)
-            .map(v => this.generateConstructorFunction(v))
-            .join("\n");
-        const FilteredMembers = filterFunctionConflict(node.namespace, node, node.members, []);
-        const Members = (options.promisify ? promisifyFunctions(FilteredMembers) : FilteredMembers)
-            .map(v => v.asString(this))
-            .join("\n");
-        // So we can use GObject.GType
-        this.namespace.assertInstalledImport("GObject");
-        return `${hasCallbacks
-            ? `export module ${name} {
-                ${node.callbacks.map(c => c.asString(this)).join("\n")}
-}`
-            : ""}
-  
-${this.docString(node)}export class ${name}${Generics}${Extends} {${node.__ts__indexSignature ? `\n${node.__ts__indexSignature}\n` : ""}
-    static $gtype: ${namespace.namespace !== "GObject" ? "GObject." : ""}GType<${name}>;
-
-    ${MainConstructor}
-    constructor(copy: ${node.name});
-    
-    ${node.props.length > 0 ? "// Properties" : ""}
-    ${Properties}
-        
-    ${node.fields.length > 0 ? "// Fields" : ""}
-    ${Fields}
-
-    ${node.constructors.length > 0 ? "// Constructors" : ""}
-    ${Constructors}
-      
-    ${node.members.length > 0 ? "// Members" : ""}
-    ${Members}
-}`;
-    }
-    generateClass(node) {
-        const { options, namespace } = this;
-        const name = node.name;
-        const injectConstructorBucket = !node.mainConstructor;
-        let Generics = "";
-        let GenericTypes = "";
-        if (node.generics.length > 0) {
-            Generics = `${this.generateGenerics(node.generics)}`;
-            GenericTypes = `${this.generateGenerics(node.generics, false)}`;
-        }
-        const Extends = this.extends(node);
-        const Implements = this.implements(node);
-        const implementedProperties = node.implementedProperties();
-        const implementedMethods = node.implementedMethods(implementedProperties);
-        let MainConstructor = "";
-        if (node.mainConstructor) {
-            MainConstructor = `\n${node.mainConstructor.asString(this)}`;
-        }
-        else {
-            MainConstructor = `\nconstructor(properties?: Partial<${name}.ConstructorProperties${GenericTypes}>, ...args: any[]);\n`;
-            // TODO: options migration
-            //if (!options.noInitTypes) {
-            //    MainConstructor += `_init(properties?: Partial<${name}.ConstructorProperties${GenericTypes}>, ...args: any[]): void;\n`;
-            //} else {
-            MainConstructor += "_init(...args: any[]): void;\n";
-            //}
-        }
-        const ConstructorProps = filterConflicts(node.namespace, node, 
-        // TODO: Include properties from interface parents too.
-        node.props)
-            .map(v => v.asString(this, true))
-            .join("\n    ");
-        const Properties = filterConflicts(node.namespace, node, node.props)
-            .map(v => v.asString(this))
-            .join("\n    ");
-        const Fields = filterConflicts(node.namespace, node, node.fields)
-            .map(v => v.asString(this))
-            .join("\n    ");
-        const Constructors = filterFunctionConflict(node.namespace, node, node.constructors, [])
-            .map(v => this.generateConstructorFunction(v))
-            .join("\n    ");
-        const FilteredMembers = filterFunctionConflict(node.namespace, node, node.members, []);
-        const Members = (options.promisify ? promisifyFunctions(FilteredMembers) : FilteredMembers)
-            .map(v => v.asString(this))
-            .join("\n    ");
-        const ImplementedProperties = filterConflicts(node.namespace, node, implementedProperties)
-            .map(m => m.asString(this))
-            .join("\n    ");
-        const FilteredImplMethods = filterFunctionConflict(node.namespace, node, implementedMethods, []);
-        const ImplementedMethods = (options.promisify ? promisifyFunctions(FilteredImplMethods) : FilteredImplMethods)
-            .map(m => m.asString(this))
-            .join("\n    ");
-        // TODO Move these to a cleaner place.
-        const Connect = new IntrospectedClassFunction({
-            name: "connect",
-            parent: node,
-            parameters: [
-                new IntrospectedFunctionParameter({
-                    name: "id",
-                    type: StringType,
-                    direction: GirDirection.In
-                }),
-                new IntrospectedFunctionParameter({
-                    name: "callback",
-                    type: AnyFunctionType,
-                    direction: GirDirection.In
-                })
-            ],
-            return_type: NumberType
-        });
-        const ConnectAfter = new IntrospectedClassFunction({
-            name: "connect_after",
-            parent: node,
-            parameters: [
-                new IntrospectedFunctionParameter({
-                    name: "id",
-                    type: StringType,
-                    direction: GirDirection.In
-                }),
-                new IntrospectedFunctionParameter({
-                    name: "callback",
-                    type: AnyFunctionType,
-                    direction: GirDirection.In
-                })
-            ],
-            return_type: NumberType
-        });
-        const Emit = new IntrospectedClassFunction({
-            name: "emit",
-            parent: node,
-            parameters: [
-                new IntrospectedFunctionParameter({
-                    name: "id",
-                    type: StringType,
-                    direction: GirDirection.In
-                }),
-                new IntrospectedFunctionParameter({
-                    name: "args",
-                    isVarArgs: true,
-                    type: new ArrayType(AnyType),
-                    direction: GirDirection.In
-                })
-            ],
-            return_type: VoidType
-        });
-        let default_signals = [];
-        let hasConnect, hasConnectAfter, hasEmit;
-        if (node.signals.length > 0) {
-            hasConnect = node.members.some(m => m.name === "connect");
-            hasConnectAfter = node.members.some(m => m.name === "connect_after");
-            hasEmit = node.members.some(m => m.name === "emit");
-            if (!hasConnect) {
-                default_signals.push(Connect);
-            }
-            if (!hasConnectAfter) {
-                default_signals.push(ConnectAfter);
-            }
-            if (!hasEmit) {
-                default_signals.push(Emit);
-            }
-            default_signals = filterConflicts(namespace, node, default_signals, FilterBehavior.DELETE);
-            hasConnect = !default_signals.some(s => s.name === "connect");
-            hasConnectAfter = !default_signals.some(s => s.name === "connect_after");
-            hasEmit = !default_signals.some(s => s.name === "emit");
-        }
-        const SignalsList = [
-            // TODO Relocate these.
-            ...default_signals.map(s => s.asString(this)),
-            ...node.signals
-                .map(s => {
-                const methods = [];
-                if (!hasConnect)
-                    methods.push(s.asString(this, IntrospectedSignalType.CONNECT));
-                if (!hasConnectAfter)
-                    methods.push(s.asString(this, IntrospectedSignalType.CONNECT_AFTER));
-                if (!hasEmit)
-                    methods.push(s.asString(this, IntrospectedSignalType.EMIT));
-                return methods;
-            })
-                .flat()
-        ];
-        const hasSignals = SignalsList.length > 0;
-        const Signals = SignalsList.join("\n");
-        const hasCallbacks = node.callbacks.length > 0;
-        const hasModule = injectConstructorBucket || hasCallbacks;
-        // So we can use GObject.GType
-        this.namespace.assertInstalledImport("GObject");
-        const parts = Extends.split("<");
-        const ExtendsInterface = parts[0];
-        let ExtendsGenerics = parts[1] ?? "";
-        if (ExtendsGenerics.length > 0) {
-            ExtendsGenerics = `<${ExtendsGenerics}`;
-        }
-        return `${hasModule
-            ? `export module ${name} {
-                ${hasCallbacks ? node.callbacks.map(c => c.asString(this)).join("\n") : ""}
-                ${injectConstructorBucket
-                ? `export interface ConstructorProperties${Generics}${Extends ? `${ExtendsInterface}.ConstructorProperties${ExtendsGenerics}` : ""} {
-    [key: string]: any;
-    ${ConstructorProps}
-}`
-                : ""}
-}`
-            : ""}
-      export ${node.isAbstract ? "abstract " : ""}class ${name}${Generics}${Extends}${Implements} {${node.__ts__indexSignature ? `\n${node.__ts__indexSignature}\n` : ""}
-      static $gtype: ${namespace.namespace !== "GObject" ? "GObject." : ""}GType<${name}>;
-
-      ${MainConstructor}
-      
-      ${node.props.length > 0 ? "// Properties" : ""}
-      ${Properties}
-      
-      ${node.fields.length > 0 ? "// Fields" : ""}
-      ${Fields}
-  
-      ${hasSignals ? "// Signals\n" : ""}
-      ${Signals}
-    
-      ${implementedProperties.length > 0 ? "// Implemented Properties\n" : ""}
-      ${ImplementedProperties}
-    
-      ${node.constructors.length > 0 ? "// Constructors\n" : ""}
-      ${Constructors}
-      
-      ${node.members.length > 0 ? "// Members\n" : ""}
-      ${Members}
-      
-      ${implementedMethods.length > 0 ? "// Implemented Members\n" : ""}
-      ${ImplementedMethods}
-}`;
-    }
-    generateField(node) {
-        const { namespace, options } = this;
-        const { name, computed } = node;
-        const invalid = isInvalid(name);
-        const Static = node.isStatic ? "static" : "";
-        const ReadOnly = node.writable ? "" : "readonly";
-        const Modifier = [Static, ReadOnly].filter(a => a !== "").join(" ");
-        const Name = computed ? `[${name}]` : invalid ? `"${name}"` : name;
-        let { type } = node;
-        let fieldAnnotation = "";
-        if (type instanceof TypeConflict) {
-            if (type.conflictType === ConflictType.PROPERTY_ACCESSOR_CONFLICT) {
-                fieldAnnotation = `// This accessor conflicts with a property, field, or function name in a parent class or interface.
-// @ts-expect-error\n`;
-            }
-            type = new BinaryType(type.unwrap(), AnyType);
-        }
-        return `${this.docString(node)}${fieldAnnotation}${Modifier} ${Name}${node.optional ? "?" : ""}: ${type
-            .resolve(namespace, options)
-            .rootPrint(namespace, options)};`;
-    }
-    generateProperty(node, construct = false) {
-        const { namespace, options } = this;
-        const invalid = isInvalid(node.name);
-        const Name = invalid ? `"${node.name}"` : node.name;
-        let type = node.type;
-        let getterAnnotation = "";
-        let setterAnnotation = "";
-        let getterSetterAnnotation = "";
-        if (type instanceof TypeConflict) {
-            switch (type.conflictType) {
-                case ConflictType.FUNCTION_NAME_CONFLICT:
-                case ConflictType.FIELD_NAME_CONFLICT:
-                    getterSetterAnnotation = setterAnnotation =
-                        "// This accessor conflicts with a property, field, or function name in a parent class or interface.\n";
-                case ConflictType.ACCESSOR_PROPERTY_CONFLICT:
-                    getterSetterAnnotation = getterAnnotation =
-                        "// This accessor conflicts with a property, field, or function name in a parent class or interface.\n";
-                    type = new BinaryType(type.unwrap(), AnyType);
-                    break;
-                case ConflictType.PROPERTY_ACCESSOR_CONFLICT:
-                    type = new BinaryType(type.unwrap(), AnyType);
-                    break;
-                case ConflictType.PROPERTY_NAME_CONFLICT:
-                    getterSetterAnnotation =
-                        setterAnnotation =
-                            getterAnnotation =
-                                "// This accessor conflicts with another accessor's type in a parent class or interface.\n";
-                    type = new BinaryType(type.unwrap(), AnyType);
-                    break;
-            }
-            if (construct && !(type instanceof BinaryType)) {
-                // For constructor properties we just convert to any.
-                type = new BinaryType(type, AnyType);
-            }
-        }
-        const Type = type.resolve(namespace, options).rootPrint(namespace, options) || "any";
-        if (construct) {
-            return `${Name}: ${Type};`;
-        }
-        const { readable, writable, constructOnly } = node;
-        const hasGetter = readable;
-        const hasSetter = writable && !constructOnly;
-        if (node.parent instanceof IntrospectedInterface) {
-            if (!hasSetter && hasGetter) {
-                return `readonly ${Name}: ${Type};`;
-            }
-            else {
-                return `${Name}: ${Type};`;
-            }
-        }
-        if (hasGetter && hasSetter) {
-            return `${getterAnnotation} get ${Name}(): ${Type};
-              ${setterAnnotation} set ${Name}(val: ${Type});`;
-        }
-        else if (hasGetter) {
-            return `${getterSetterAnnotation} get ${Name}(): ${Type};`;
-        }
-        else {
-            return `${getterSetterAnnotation} set ${Name}(val: ${Type});`;
-        }
-    }
-    generateSignal(node, type = IntrospectedSignalType.CONNECT) {
-        switch (type) {
-            case IntrospectedSignalType.CONNECT:
-                return node.asConnect(false).asString(this);
-            case IntrospectedSignalType.CONNECT_AFTER:
-                return node.asConnect(true).asString(this);
-            case IntrospectedSignalType.EMIT:
-                return node.asEmit().asString(this);
-        }
-    }
-    generateEnumMember(node) {
-        const invalid = isInvalid(node.name);
-        if (node.value != null && !Number.isNaN(Number.parseInt(node.value, 10))) {
-            return invalid
-                ? `${this.docString(node)}"${node.name}" = ${node.value},`
-                : `${this.docString(node)}${node.name} = ${node.value},`;
-        }
-        else {
-            return invalid ? `${this.docString(node)}"${node.name}",` : `${this.docString(node)}${node.name},`;
-        }
-    }
-    generateParameter(node) {
-        const { namespace, options } = this;
-        const type = resolveDirectedType(node.type, node.direction)?.resolve(namespace, options).rootPrint(namespace, options) ??
-            node.type.resolve(namespace, options).rootPrint(namespace, options);
-        if (node.isVarArgs) {
-            return `...args: ${type}`;
-        }
-        if (node.isOptional) {
-            return `${node.name}?: ${type}`;
-        }
-        else {
-            return `${node.name}: ${type}`;
-        }
-    }
-    docString(node) {
-        // TODO: Support node.doc not being a string?
-        return typeof node.doc === "string" && !this.options.noComments
-            ? `/**
-${node.doc
-                .split("\n")
-                .map(line => ` * ${line
-                .trim()
-                .replace("*/", "*\\/")
-                .replace(/@([a-z_]+?)([. ])/g, "`$1$2`")}`.replace(/@([a-z])/g, "$1"))
-                .join("\n")}
-    */\n`
-            : "";
-    }
-    generateFunction(node) {
-        const { namespace } = this;
-        // Register our identifier with the sanitized identifiers.
-        // We avoid doing this in fromXML because other class-level function classes
-        // depends on that code.
-        sanitizeIdentifierName(namespace.namespace, node.raw_name);
-        const Parameters = this.generateParameters(node.parameters);
-        const ReturnType = this.generateReturn(node.return(), node.output_parameters);
-        const Generics = this.generateGenerics(node.generics);
-        return `${this.docString(node)}export function ${node.name}${Generics}(${Parameters}): ${ReturnType};`;
-    }
-    generateConstructorFunction(node) {
-        const { namespace, options } = this;
-        const Parameters = this.generateParameters(node.parameters);
-        const invalid = isInvalid(node.name);
-        const name = invalid ? `["${node.name}"]` : node.name;
-        const warning = node.getWarning();
-        return `${warning ? `${warning}\n` : ""}${this.docString(node)}static ${name}(${Parameters}): ${node
-            .return()
-            .resolve(namespace, options)
-            .rootPrint(namespace, options)};`;
-    }
-    generateConstructor(node) {
-        const Parameters = this.generateParameters(node.parameters);
-        return `constructor(${Parameters});`;
-    }
-    generateDirectAllocationConstructor(node) {
-        const ConstructorFields = node.parameters.map(param => param.asField().asString(this)).join("\n");
-        return `
-    constructor(properties?: Partial<{
-      ${ConstructorFields}
-    }>);`;
-    }
-    generateClassFunction(node) {
-        const invalid = isInvalid(node.name);
-        const parameters = node.parameters;
-        const output_parameters = node.output_parameters;
-        const return_type = node.return();
-        const Parameters = this.generateParameters(parameters);
-        const ReturnType = this.generateReturn(return_type, output_parameters);
-        const Generics = this.generateGenerics(node.generics);
-        if (node.shouldAnyify()) {
-            return `${invalid ? `["${node.name}"]` : node.name}: ${Generics}((${Parameters}) => ${ReturnType}) | any;`;
-        }
-        const warning = node.getWarning();
-        return `${warning ? `${warning}\n` : ""}${this.docString(node)}${invalid ? `["${node.name}"]` : node.name}${Generics}(${Parameters}): ${ReturnType};`;
-    }
-    generateStaticClassFunction(node) {
-        const Generics = this.generateGenerics(node.generics);
-        const ReturnType = this.generateReturn(node.return(), node.output_parameters);
-        const warning = node.getWarning();
-        return `${warning ? `${warning}\n` : ""}${this.docString(node)}static ${node.name}${Generics}(${this.generateParameters(node.parameters)}): ${ReturnType};`;
-    }
-    generateAlias(node) {
-        const { namespace, options } = this;
-        const Type = node.type.resolve(namespace, options).print(namespace, options);
-        const GenericBase = node.generics
-            .map(g => {
-            if (g.type) {
-                return `${g.name} = ${g.type.resolve(namespace, options).rootPrint(namespace, options)}`;
-            }
-            return `${g.name}`;
-        })
-            .join(", ");
-        const Generic = GenericBase ? `<${GenericBase}>` : "";
-        return `${this.docString(node)}export type ${node.name}${Generic} = ${Type};`;
-    }
-    generateVirtualClassFunction(node) {
-        return this.generateClassFunction(node);
-    }
-}
-//# sourceMappingURL=dts.js.map