@ts-for-gir/cli 3.0.0-beta.10

package/src/gir-factory.ts

@@ -0,0 +1,526 @@
+import type {
+    GirFunctionElement,
+    GirDocElement,
+    GirVirtualMethodElement,
+    GirCallableParamElement,
+    GirConstructorElement,
+    GirMethodElement,
+    GirInstanceParameter,
+    GirPropertyElement,
+    GirAnnotation,
+    TsFunction,
+    TsMethod,
+    TsParameter,
+    TsGenericParameter,
+    TsProperty,
+    TsType,
+    TsDoc,
+    InjectionFunction,
+    InjectionInstanceParameter,
+    InjectionGenericParameter,
+    InjectionType,
+    InjectionParameter,
+    InjectionProperty,
+    Environment,
+    TypeGirProperty,
+    TypeGirElement,
+    TypeGirFunction,
+    TypeGirEnumerationMember,
+    TypeTsElement,
+    TypeTsEnumerationMember,
+    TypeTsFunction,
+    TypeTsProperty,
+    TsClass,
+    TsInstanceParameter,
+} from './types/index.js'
+
+import { GENERIC_NAMES } from './constants.js'
+
+/**
+ * Creates new gir and ts objects
+ */
+export class GirFactory {
+    newGenerics(generics: InjectionGenericParameter[]) {
+        const tsGenerics: TsGenericParameter[] = []
+        for (let i = 0; i < generics.length; i++) {
+            const generic = generics[i]
+            const tsGeneric: TsGenericParameter = {
+                name: generic.name || GENERIC_NAMES[i],
+                ...generic,
+            }
+            tsGenerics.push(tsGeneric)
+        }
+        return tsGenerics
+    }
+
+    girTypeNameToTsTypeName(girTypeName: 'alias', isStatic: boolean): 'type'
+    girTypeNameToTsTypeName(girTypeName: 'enum' | 'bitfield', isStatic: boolean): 'enum'
+    girTypeNameToTsTypeName(girTypeName: TypeGirEnumerationMember, isStatic: boolean): TypeTsEnumerationMember
+    girTypeNameToTsTypeName(girTypeName: 'callback', isStatic: boolean): 'interface'
+    girTypeNameToTsTypeName(girTypeName: 'class' | 'interface' | 'union' | 'record', isStatic: boolean): 'class'
+    girTypeNameToTsTypeName(girTypeName: 'constant', isStatic: boolean): 'constant'
+    girTypeNameToTsTypeName(girTypeName: 'constructor', isStatic: boolean): 'constructor' | 'static-function'
+    girTypeNameToTsTypeName(girTypeName: 'method' | 'virtual', isStatic: boolean): 'method'
+    girTypeNameToTsTypeName(girTypeName: 'signal' | 'method', isStatic: boolean): 'event-methods'
+    girTypeNameToTsTypeName(girTypeName: 'static-function', isStatic: true): 'static-function'
+    girTypeNameToTsTypeName(girTypeName: 'function', isStatic: true): 'static-function'
+    girTypeNameToTsTypeName(girTypeName: 'function', isStatic: false): 'function'
+    girTypeNameToTsTypeName(girTypeName: TypeGirProperty, isStatic: boolean): TypeTsProperty
+    girTypeNameToTsTypeName(girTypeName: TypeGirProperty, isStatic: false): 'property' | 'constructor-property'
+    girTypeNameToTsTypeName(girTypeName: TypeGirProperty, isStatic: true): 'static-property'
+    girTypeNameToTsTypeName(girTypeName: TypeGirFunction, isStatic: boolean): TypeTsFunction
+    girTypeNameToTsTypeName(girTypeName: TypeGirElement, isStatic: boolean): TypeTsElement {
+        switch (girTypeName) {
+            case 'alias':
+                return 'type'
+            case 'enum':
+            case 'bitfield':
+                return 'enum'
+            case 'enum-member':
+            case 'bitfield-member':
+                return 'enum-member'
+            case 'callback':
+                return 'interface'
+            case 'class':
+            case 'interface':
+            case 'union':
+            case 'record':
+                return 'class'
+            case 'constant':
+                return 'constant'
+            case 'constructor':
+                return 'constructor'
+            case 'method':
+            case 'virtual':
+                return 'method'
+            case 'signal':
+                return 'event-methods'
+            case 'static-function':
+                return 'static-function'
+            case 'function':
+                if (typeof isStatic === 'undefined') {
+                    throw new Error(
+                        'You must specify if the function is static or not if you want to convert the type of a function!',
+                    )
+                }
+                if (isStatic) {
+                    return 'static-function'
+                }
+                return 'function'
+            case 'field':
+            case 'property':
+                if (typeof isStatic === 'undefined') {
+                    throw new Error(
+                        'You must specify if the property is static or not if you want to convert the type of a function!',
+                    )
+                }
+                if (isStatic) {
+                    return 'static-property'
+                }
+                return 'property'
+        }
+        throw new Error(`Unknown gir type: "${String(girTypeName)}"!`)
+    }
+
+    newGirFunctions(
+        injectFunctions: InjectionFunction[],
+        parent: TsClass | null,
+        overrideToAll: Partial<InjectionFunction> = {},
+    ) {
+        const girFunctionElements: Array<
+            GirConstructorElement & GirFunctionElement & GirMethodElement & GirVirtualMethodElement
+        > = []
+        for (let injectFunction of injectFunctions) {
+            injectFunction = { ...injectFunction, ...overrideToAll }
+            girFunctionElements.push(this.newGirFunction(injectFunction, parent))
+        }
+        return girFunctionElements
+    }
+
+    newGirFunction(
+        tsData: InjectionFunction,
+        parent: TsClass | null,
+    ): GirConstructorElement & GirFunctionElement & GirMethodElement & GirVirtualMethodElement {
+        const _tsData = this.newTsFunction(tsData, parent)
+        return {
+            $: this.newGirAttr(_tsData.name),
+            ...this.newGirDocElement(),
+            _tsData,
+        }
+    }
+
+    newGirCallableParamElement(
+        tsData: InjectionParameter | GirCallableParamElement,
+        parent: TsFunction,
+    ): GirCallableParamElement {
+        return {
+            $: this.newGirAttr(),
+            ...this.newGirDocElement(),
+            _tsData: this.newTsParameter(tsData, parent),
+        }
+    }
+
+    newGirCallableParamElements(
+        injectionParams: Array<InjectionParameter | GirCallableParamElement> = [],
+        parent: TsFunction,
+    ): GirCallableParamElement[] {
+        const result: GirCallableParamElement[] = []
+        for (const injectionParam of injectionParams) {
+            result.push(this.newGirCallableParamElement(injectionParam, parent))
+        }
+        return result
+    }
+
+    newGirInstanceParameter(
+        data: InjectionInstanceParameter | GirInstanceParameter | TsInstanceParameter,
+    ): GirInstanceParameter {
+        const tsData = (data as GirInstanceParameter)._tsData
+            ? (data as GirInstanceParameter)._tsData
+            : (data as InjectionInstanceParameter | TsInstanceParameter)
+
+        return {
+            $: this.newGirAttr(),
+            ...this.newGirDocElement(),
+            _tsData: tsData,
+        }
+    }
+
+    newGirInstanceParameters(
+        injectionInstanceParams: Array<InjectionInstanceParameter | GirInstanceParameter> = [],
+    ): GirInstanceParameter[] {
+        const result: GirInstanceParameter[] = []
+        for (const injectionInstanceParam of injectionInstanceParams) {
+            result.push(this.newGirInstanceParameter(injectionInstanceParam))
+        }
+        return result
+    }
+
+    newGirProperty(tsData: InjectionProperty): GirPropertyElement {
+        const _tsData = this.newTsProperty(tsData)
+        if (!_tsData.name) throw new Error('The name property is required!')
+        return {
+            $: {
+                ...this.newGirAttr(_tsData.name),
+            },
+            annotation: [],
+            ...this.newGirDocElement(),
+            _tsData,
+        }
+    }
+
+    newGirProperties(
+        InjectionProps: InjectionProperty[],
+        overrideToAll: Partial<InjectionProperty> = {},
+    ): GirPropertyElement[] {
+        const result: GirPropertyElement[] = []
+        for (const InjectionProp of InjectionProps) {
+            result.push(this.newGirProperty({ ...InjectionProp, ...overrideToAll }))
+        }
+        return result
+    }
+
+    newTsFunction(tsData: InjectionFunction, parent: TsClass | null): TsFunction {
+        const tsFunc: TsFunction & TsMethod = {
+            ...tsData,
+            returnTypes: this.newTsTypes(tsData.returnTypes || []),
+            isArrowType: tsData.isArrowType || false,
+            isStatic: tsData.isStatic || false,
+            isGlobal: tsData.isGlobal || false,
+            isVirtual: tsData.isVirtual || false,
+            isInjected: tsData.isInjected || false,
+            retTypeIsVoid: tsData.returnTypes?.length === 1 && tsData.returnTypes[0]?.type === 'void',
+            generics: this.newGenerics(tsData.generics || []),
+            overloads: tsData.overloads || [],
+            doc: this.newTsDoc(tsData.doc),
+            tsTypeName: this.girTypeNameToTsTypeName(tsData.girTypeName, tsData.isStatic || false),
+            inParams: [],
+            outParams: [],
+            instanceParameters: [],
+            parent,
+        }
+
+        tsFunc.inParams.push(...this.newGirCallableParamElements(tsData.inParams, tsFunc))
+        tsFunc.outParams.push(...this.newGirCallableParamElements(tsData.outParams, tsFunc))
+        tsFunc.instanceParameters.push(...this.newGirInstanceParameters(tsData.instanceParameters))
+
+        return tsFunc
+    }
+
+    newTsProperty(tsData: InjectionProperty): TsProperty {
+        tsData.type ||= [this.newTsType()]
+        const tsProp: TsProperty = {
+            ...tsData,
+            readonly: tsData.readonly || false,
+            isStatic: tsData.isStatic || false,
+            isInjected: tsData.isInjected || false,
+            type: this.newTsTypes(tsData.type || []),
+            doc: this.newTsDoc(tsData.doc),
+            tsTypeName: this.girTypeNameToTsTypeName(tsData.girTypeName, tsData.isStatic || false),
+        }
+        return tsProp
+    }
+
+    newTsType(tsData: InjectionType = {}): TsType {
+        tsData.callbacks ||= []
+        tsData.generics ||= []
+        tsData.nullable ||= false
+        tsData.optional ||= false
+
+        const newTsData: TsType = {
+            type: tsData.type || 'void',
+            callbacks: tsData.callbacks || [],
+            generics: tsData.generics || [],
+            nullable: tsData.nullable || false,
+            optional: tsData.optional || false,
+            isArray: tsData.isArray || false,
+            isCallback: tsData.isCallback || false,
+            isFunction: tsData.isFunction || false,
+            leftSeparator: tsData.leftSeparator || '|',
+        }
+
+        return newTsData
+    }
+
+    newTsTypes(tsDataArr: InjectionType[]): TsType[] {
+        const types: TsType[] = []
+        for (const tsData of tsDataArr) {
+            types.push(this.newTsType(tsData))
+        }
+
+        if (tsDataArr.length === 0) {
+            types.push(this.newTsType({}))
+        }
+
+        return types
+    }
+
+    newTsParameter(tsData: InjectionParameter | GirCallableParamElement, parent: TsFunction) {
+        const types: TsType[] = []
+        const tsTypes = (tsData as GirCallableParamElement)._tsData?.type || (tsData as InjectionParameter).type || []
+        for (const type of tsTypes) {
+            type.type = type.type || 'any'
+            types.push(this.newTsType(type))
+        }
+
+        const name = (tsData as InjectionParameter).name || (tsData as GirCallableParamElement)._tsData?.name
+        const isRest =
+            (tsData as InjectionParameter).isRest || (tsData as GirCallableParamElement)._tsData?.isRest || false
+        const doc = (tsData as InjectionParameter).doc || (tsData as GirCallableParamElement)._tsData?.doc
+
+        if (!name) throw new Error('[GirFactory.newTsParameter] The name property is required!')
+
+        const newTsData: TsParameter = {
+            type: types,
+            name: name,
+            isRest: isRest,
+            girTypeName: 'callable-param',
+            doc: this.newTsDoc(doc),
+            parent,
+        }
+
+        return newTsData
+    }
+
+    newTsParameters(datas: Array<InjectionParameter | GirCallableParamElement>, parent: TsFunction) {
+        const tsParameters: TsParameter[] = []
+        for (const data of datas) {
+            tsParameters.push(this.newTsParameter(data, parent))
+        }
+        return tsParameters
+    }
+
+    /**
+     * Generates signal methods like `connect`, `connect_after` and `emit` on Gjs or `connect`, `on`, `once`, `off` and `emit` an node-gtk
+     * for a default gir signal element
+     * @param signalName The signal name
+     * @param callbackType The callback type
+     * @param emitInParams
+     * @param environment
+     * @param withDisconnect If `true` this also generates a `disconnect` method
+     * @returns
+     */
+    newTsSignalMethods(
+        signalName: string | undefined,
+        callbackType: string | undefined,
+        emitInParams: InjectionParameter[],
+        parentClass: TsClass,
+        environment: Environment,
+        withDisconnect = false,
+    ) {
+        const tsMethods: TsMethod[] = []
+        const girTypeName: TypeGirFunction = 'signal'
+
+        const sigNameInParam: InjectionParameter = {
+            name: 'sigName',
+            type: [
+                this.newTsType({
+                    type: signalName ? `"${signalName}"` : 'string',
+                }),
+            ],
+            doc: this.newTsDoc(),
+        }
+
+        const anyArgsInParam: InjectionParameter = {
+            name: 'args',
+            isRest: true,
+            type: [
+                this.newTsType({
+                    type: `any`,
+                    isArray: true,
+                }),
+            ],
+            doc: this.newTsDoc(),
+        }
+
+        emitInParams.push(anyArgsInParam)
+
+        const callbackInParam: InjectionParameter = {
+            name: 'callback',
+            type: [
+                this.newTsType({
+                    type: callbackType || '(...args: any[]) => void',
+                }),
+            ],
+            doc: this.newTsDoc(),
+        }
+
+        const numberReturnType = this.newTsType({
+            type: 'number',
+        })
+
+        const connectTsFn = this.newTsFunction(
+            {
+                name: 'connect',
+                inParams: [sigNameInParam, callbackInParam],
+                returnTypes: [numberReturnType],
+                girTypeName,
+            },
+            parentClass,
+        )
+        tsMethods.push(connectTsFn)
+
+        if (environment === 'gjs') {
+            const connectAfterTsFn = this.newTsFunction(
+                {
+                    name: 'connect_after',
+                    inParams: [sigNameInParam, callbackInParam],
+                    returnTypes: [numberReturnType],
+                    girTypeName,
+                },
+                parentClass,
+            )
+            tsMethods.push(connectAfterTsFn)
+        } else if (environment === 'node') {
+            const afterInParam: InjectionParameter = {
+                name: 'after',
+                type: [
+                    this.newTsType({
+                        type: 'boolean',
+                        optional: true,
+                    }),
+                ],
+                doc: this.newTsDoc(),
+            }
+
+            const nodeEventEmitterReturnType = this.newTsType({
+                type: 'NodeJS.EventEmitter',
+            })
+
+            const onTsFn = this.newTsFunction(
+                {
+                    name: 'on',
+                    inParams: [sigNameInParam, callbackInParam, afterInParam],
+                    returnTypes: [nodeEventEmitterReturnType],
+                    girTypeName,
+                },
+                parentClass,
+            )
+            const onceTsFn = this.newTsFunction(
+                {
+                    name: 'once',
+                    inParams: [sigNameInParam, callbackInParam, afterInParam],
+                    returnTypes: [nodeEventEmitterReturnType],
+                    girTypeName,
+                },
+                parentClass,
+            )
+            const offTsFn = this.newTsFunction(
+                {
+                    name: 'off',
+                    inParams: [sigNameInParam, callbackInParam],
+                    returnTypes: [nodeEventEmitterReturnType],
+                    girTypeName,
+                },
+                parentClass,
+            )
+            tsMethods.push(onTsFn, onceTsFn, offTsFn)
+        }
+
+        const emitTsFn = this.newTsFunction(
+            {
+                name: 'emit',
+                inParams: [sigNameInParam, ...emitInParams],
+                girTypeName,
+            },
+            parentClass,
+        )
+        tsMethods.push(emitTsFn)
+
+        if (withDisconnect && environment === 'gjs') {
+            const idInParam: InjectionParameter = {
+                name: 'id',
+                type: [
+                    this.newTsType({
+                        type: 'number',
+                    }),
+                ],
+                doc: this.newTsDoc(),
+            }
+
+            const emitTsFn = this.newTsFunction(
+                {
+                    name: 'disconnect',
+                    inParams: [idInParam],
+                    girTypeName,
+                },
+                parentClass,
+            )
+            tsMethods.push(emitTsFn)
+        }
+
+        return tsMethods
+    }
+
+    newGirAttr(
+        name = '',
+    ): (GirConstructorElement & GirFunctionElement & GirMethodElement & GirVirtualMethodElement)['$'] {
+        return {
+            name,
+            'glib:set-property': '',
+            'glib:get-property': '',
+        }
+    }
+
+    newGirAnnotation(data: Partial<GirAnnotation['$']> = {}): GirAnnotation {
+        data.name ||= ''
+        data.value ||= []
+        return {
+            $: data as GirAnnotation['$'],
+        }
+    }
+
+    newGirDocElement(text = '', filename = '', line = '', column = ''): GirDocElement {
+        return {
+            doc: [{ $: { filename, line, column }, _: text }],
+            'doc-deprecated': [{ $: {}, _: '' }],
+            'source-position': [{ filename: '', line: '', column: [''] }],
+        }
+    }
+
+    newTsDoc(data: Partial<TsDoc> = {}): TsDoc {
+        return {
+            tags: data.tags || [],
+            text: data.text || '',
+        }
+    }
+}