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

package/src/types/ts-parameter.ts

@@ -0,0 +1,20 @@
+import { TsType, TsDoc, TypeGirParameter, TsFunction } from './index.js'
+
+/**
+ * Holds the data to generate a parameter of a function or return value in/for Typescript
+ */
+export interface TsParameter {
+    name: string
+    type: TsType[]
+
+    /** The parent function of this parameter */
+    parent: TsFunction
+
+    /** If `true` the parameter is a rest parameter like `(...names: string[])` */
+    isRest: boolean
+
+    girTypeName: TypeGirParameter
+
+    /** Typescript data to generate documentations in TSDoc style */
+    doc: TsDoc
+}

package/src/types/ts-property.ts

@@ -0,0 +1,22 @@
+import { TsVar, TsDoc, TypeGirProperty, TypeTsProperty } from './index.js'
+
+/**
+ * Holds the data to generate a property in/for Typescript
+ */
+export interface TsProperty extends TsVar {
+    readonly: boolean
+    isStatic: boolean
+    /** Temporary property, we will try later to resolve the conflicts correctly */
+    hasUnresolvedConflict?: boolean
+
+    /** true if this function was injected using the `Injector`. This information is used in the `ConflictResolver` */
+    isInjected: boolean
+
+    // CUSTOM
+    girTypeName: TypeGirProperty
+    /** Will be exported in Typescript as a `field` of a `class` or as a "constructor-property" */
+    tsTypeName: TypeTsProperty
+
+    /** Typescript data to generate documentations in TSDoc style */
+    doc: TsDoc
+}

package/src/types/ts-signal.ts

@@ -0,0 +1,21 @@
+import { TsMethod, TsCallback, TsCallbackInterface } from './index.js'
+
+/**
+ * Holds the data to generate a function in/for Typescript for `GirSignal`
+ */
+export interface TsSignal extends TsCallback {
+    /** Signal functions like `connect`, `connect_after`, `disconnect` and `emit` on Gjs or `connect`, `after`, `on`, `once`, `off` and `emit` an node-gtk */
+    tsMethods: TsMethod[]
+
+    /** Signal overloads, used in `ConflictResolver` */
+    overloads: TsSignal[]
+
+    /**
+     * Interface for the callback type
+     */
+    tsCallbackInterface?: TsCallbackInterface
+
+    girTypeName: 'signal'
+    /** Signals are represented in Typescript as multiple event methods */
+    tsTypeName: 'event-methods'
+}

package/src/types/ts-type-name.ts

@@ -0,0 +1 @@
+export type TsTypeName = 'function' | 'method' | 'static-function' | 'interface' | 'event-methods' | 'constructor'

package/src/types/ts-type-separator.ts

@@ -0,0 +1 @@
+export type TsTypeSeparator = '&' | '|'

package/src/types/ts-type.ts

@@ -0,0 +1,25 @@
+import { GirCallbackElement, TsGenericParameter, TsTypeSeparator } from './index.js'
+
+/**
+ * Holds the data to generate a type in/for Typescript
+ */
+export interface TsType {
+    // TODO: move option property to `TsParameter` and add the `undefined` type to types
+    optional: boolean
+    nullable: boolean
+    type: string
+    callbacks: GirCallbackElement[]
+    generics: TsGenericParameter[]
+    // TODO: transform array to type with generics?
+    isArray: boolean
+    isFunction: boolean
+    isCallback: boolean
+    /**
+     * Left type separated, used if multiple types found.
+     * If nothing os set, `|` will be used by default.
+     *
+     * @Example
+     * `string | number` or `Gtk.Window & Gtk.Widget`
+     * */
+    leftSeparator?: TsTypeSeparator
+}

package/src/types/ts-var.ts

@@ -0,0 +1,21 @@
+import { TsType, TsDoc } from './index.js'
+
+/**
+ * Holds the data to generate a variable in/for Typescript
+ */
+export interface TsVar {
+    name: string | null
+    type: TsType[]
+    /** Temporary property, we will try later to resolve the conflicts correctly */
+    hasUnresolvedConflict?: boolean
+
+    /** true if this function was injected using the `Injector`. This information is used in the `ConflictResolver` */
+    isInjected: boolean
+
+    girTypeName: 'constant' | 'field' | 'property'
+    /** Will be exported in Typescript as a `constant` or a `field` of a `class` */
+    tsTypeName: 'constant' | 'static-property' | 'property' | 'constructor-property'
+
+    /** Typescript data to generate documentations in TSDoc style */
+    doc: TsDoc
+}

package/src/types/type-gir-alias.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript `type` */
+export type TypeGirAlias = 'alias'

package/src/types/type-gir-class.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript class */
+export type TypeGirClass = 'class' | 'record' | 'interface' | 'union'

package/src/types/type-gir-element.ts

@@ -0,0 +1,25 @@
+import {
+    TypeGirClass,
+    TypeGirMethod,
+    TypeGirVariable,
+    TypeGirAlias,
+    TypeGirEnumeration,
+    TypeGirEnumerationMember,
+    TypeGirInterface,
+    TypeGirParameter,
+    TypeGirProperty,
+    TypeGirFunction,
+} from './index.js'
+
+/** Any gir element type */
+export type TypeGirElement =
+    | TypeGirClass
+    | TypeGirMethod
+    | TypeGirVariable
+    | TypeGirAlias
+    | TypeGirEnumeration
+    | TypeGirEnumerationMember
+    | TypeGirInterface
+    | TypeGirParameter
+    | TypeGirProperty
+    | TypeGirFunction

package/src/types/type-gir-enumeration-member.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript enumeration */
+export type TypeGirEnumerationMember = 'enum-member' | 'bitfield-member'

package/src/types/type-gir-enumeration.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript enumeration */
+export type TypeGirEnumeration = 'enum' | 'bitfield'

package/src/types/type-gir-function.ts

@@ -0,0 +1,8 @@
+export type TypeGirFunction =
+    | 'constructor'
+    | 'function'
+    | 'method'
+    | 'static-function'
+    | 'signal'
+    | 'virtual'
+    | 'callback'

package/src/types/type-gir-interface.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript interface */
+export type TypeGirInterface = 'callback'

package/src/types/type-gir-method.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript method (or static function) of a class */
+export type TypeGirMethod = 'virtual' | 'signal' | 'method' | 'constructor' | 'function' | 'static'

package/src/types/type-gir-parameter.ts

@@ -0,0 +1 @@
+export type TypeGirParameter = 'callable-param'

package/src/types/type-gir-property.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript field / property */
+export type TypeGirProperty = 'property' | 'field' | 'constant'

package/src/types/type-gir-variable.ts

@@ -0,0 +1 @@
+export type TypeGirVariable = 'constant'

package/src/types/type-ts-element.ts

@@ -0,0 +1,13 @@
+import { TypeTsFunction, TypeTsProperty } from './index.js'
+
+/** Any typescript element type */
+export type TypeTsElement =
+    | 'class'
+    | 'interface'
+    | 'enum'
+    | 'enum-member'
+    | 'constant'
+    | 'event-methods'
+    | 'type'
+    | TypeTsFunction
+    | TypeTsProperty

package/src/types/type-ts-enumeration-member.ts

@@ -0,0 +1,2 @@
+/** All gir elements which can be a typescript enumeration */
+export type TypeTsEnumerationMember = 'enum-member'

package/src/types/type-ts-function.ts

@@ -0,0 +1 @@
+export type TypeTsFunction = 'static-function' | 'constructor' | 'function' | 'method' | 'event-methods' | 'interface'

package/src/types/type-ts-property.ts

@@ -0,0 +1 @@
+export type TypeTsProperty = 'static-property' | 'property' | 'constructor-property'

package/src/types/user-config-load-result.ts

@@ -0,0 +1,6 @@
+import { UserConfig } from './user-config'
+export interface UserConfigLoadResult {
+    config: Partial<UserConfig>
+    filepath: string
+    isEmpty?: boolean | undefined
+}

package/src/types/user-config.ts

@@ -0,0 +1,39 @@
+import { BuildType, Environment, ModuleType } from './index.js'
+
+/**
+ * Types for config file
+ */
+export interface UserConfig {
+    /** javascript environment */
+    environments: Environment[]
+    /** directory to output to */
+    outdir: string | null
+    /** Definitions generation type */
+    buildType?: BuildType
+    /** Module type, can be CommonJS or ESM */
+    moduleType?: ModuleType
+    /** GIR directories */
+    girDirectories: string[]
+    /** Switch on/off the verbose mode */
+    verbose: boolean
+    /** Do not ask for package versions if multiple versions are found */
+    ignoreVersionConflicts: boolean
+    /** print the output to console and create no files */
+    print: boolean
+    /** prettifies the generated .d.ts files */
+    pretty: boolean
+    /** GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules */
+    modules: string[]
+    /** modules that should be ignored */
+    ignore?: string[]
+    /** Export all symbols for each module as a namespace */
+    useNamespace: boolean
+    /** Do not generate documentation comments */
+    noComments: boolean
+    /** Do not generate debugging inline comments */
+    noDebugComments: boolean
+    /** Disable typescript semantic checks using @ts-nocheck */
+    noCheck: boolean
+    /** Fix Inheritance and implementation type conflicts */
+    fixConflicts: boolean
+}

package/src/utils.ts

@@ -0,0 +1,217 @@
+/* eslint-disable @typescript-eslint/unbound-method */
+import lodash from 'lodash'
+import Path from 'path'
+import fs from 'fs'
+import { fileURLToPath } from 'url'
+import { Environment, GirInfoAttrs, TsType } from './types/index.js'
+import { inspect } from 'util'
+import { Logger } from './logger.js'
+
+import { COMMENT_REG_EXP, PARAM_REG_EXP, OPT_PARAM_REG_EXP } from './constants.js'
+
+export { inspect }
+
+export const isEqual = lodash.isEqual
+
+export const map = lodash.map
+
+export const find = lodash.find
+
+export const merge = lodash.merge
+
+export const clone = lodash.clone
+
+export const cloneDeep = lodash.cloneDeep
+
+export const splitModuleName = (packageName: string): { packageName: string; namespace: string; version: string } => {
+    // There are modules that use multiple hyphens like 'GUPnP-DLNA-1.0'
+    const splits = packageName.split('-')
+    const version = splits.splice(-1, 1)[0]
+    const namespace = splits.join('-')
+    return {
+        packageName,
+        namespace,
+        version,
+    }
+}
+
+/** Remove namespace prefix */
+export const removeNamespace = (type: string, namespace: string) => {
+    if (type.startsWith(namespace + '.')) {
+        type = type.substring(namespace.length + 1)
+    }
+    return type
+}
+
+/** Remove class module name prefix */
+export const removeClassModule = removeNamespace
+
+export const addNamespace = (type: string, namespace: string) => {
+    if (!type.startsWith(namespace + '.')) {
+        type = namespace + '.' + type
+    }
+    return type
+}
+
+/**
+ * Checking whether some variable is iterable
+ * see https://stackoverflow.com/a/32538867
+ * @param obj Variable to check for iterable
+ */
+export const isIterable = (obj: unknown[]): boolean => {
+    return obj != null && typeof obj[Symbol.iterator] === 'function'
+}
+
+export const isNumeric = (str: string): boolean => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return !isNaN((str as any) - parseFloat(str))
+}
+
+export const getFirstChar = (str: string): string => {
+    return str.charAt(0)
+}
+
+export const getLastChar = (str: string): string => {
+    return str.charAt(str.length - 1)
+}
+
+export const isFirstCharNumeric = (str: string): boolean => {
+    return isNumeric(getFirstChar(str))
+}
+
+export const camelCase = (str: string): string => {
+    return str
+        .replace(/\s(.)|(\s|-|_|\.)(.)/g, (a) => {
+            return a.toUpperCase()
+        })
+        .replace(/(\s|-|_|\.)/g, '')
+}
+
+export const lowerCamelCase = (str: string): string => {
+    str = camelCase(str)
+    str = getFirstChar(str).toLowerCase() + str.slice(1)
+    return str
+}
+
+export const upperCamelCase = (str: string): string => {
+    str = camelCase(str)
+    str = getFirstChar(str).toUpperCase() + str.slice(1)
+    return str
+}
+
+export const findFileInDirs = (dirs: string[], filename: string): { path: string | null; exists: boolean } => {
+    let exists = false
+    for (const dir of dirs) {
+        const filePath = Path.join(dir, filename)
+        exists = fs.existsSync(filePath)
+        if (exists) {
+            return {
+                path: filePath,
+                exists,
+            }
+        }
+    }
+    return {
+        path: null,
+        exists,
+    }
+}
+
+/**
+ * Union (a ∪ b): create a set that contains the elements of both set a and set b.
+ * See https://2ality.com/2015/01/es6-set-operations.html#union
+ * @param target
+ * @param source
+ */
+export const union = <T>(target: Set<T> | T[], source: Set<T> | T[]): Set<T> => {
+    return (target = new Set<T>([...target, ...source]))
+}
+
+export const stripParamNames = (func: string, ignoreTail = false): string => {
+    const g = func
+    func = func.replace(COMMENT_REG_EXP, '')
+    const lb = func.split('(', 2)
+    if (lb.length < 2) Logger.error(`Bad function definition ${g}`)
+    const rb = lb[1].split(')')
+    const tail = ignoreTail ? '' : rb[rb.length - 1]
+    let params = rb.slice(0, rb.length - 1).join(')')
+    params = params.replace(PARAM_REG_EXP, ':')
+    params = params.replace(OPT_PARAM_REG_EXP, '?:')
+    return `${lb[0]}(${params})${tail}`
+}
+
+export const isCommentLine = (line: string) => {
+    const lineTrim = line.trim()
+    return lineTrim.startsWith('//') || (lineTrim.startsWith('/*') && lineTrim.endsWith('*/'))
+}
+
+export const generateIndent = (indents = 1, spaceForIndent = 4): string => {
+    return ' '.repeat(indents * spaceForIndent)
+}
+
+// Get __dirname on ESM
+export const __filename = fileURLToPath(import.meta.url)
+export const __dirname = Path.dirname(__filename)
+
+export const getEnvironmentDir = (environment: Environment, baseDir: string): string => {
+    if (!baseDir.endsWith(environment))
+        if (environment === 'gjs' && !baseDir.endsWith('/Gjs')) {
+            return Path.join(baseDir, 'Gjs')
+        }
+    if (environment === 'node' && !baseDir.endsWith('/node-gtk')) {
+        return Path.join(baseDir, 'node-gtk')
+    }
+    return baseDir
+}
+
+export const getDestPath = (environment: Environment, outputDir: string, outputFilename: string) => {
+    const outputEnvDir = getEnvironmentDir(environment, outputDir)
+    const destPath = Path.join(outputEnvDir, outputFilename)
+    return destPath
+}
+
+export const girBool = (boolStr: string | undefined, defaultVal = false): boolean => {
+    if (boolStr) {
+        if (parseInt(boolStr) === 0) return false
+        return true
+    }
+    return defaultVal
+}
+
+/**
+ * Returns `true` if the definitions in `d1` and `d2` have equivalent signatures
+ * @param d1
+ * @param d2
+ */
+export const signaturesMatch = (d1: string, d2: string) => {
+    if (isCommentLine(d1) || isCommentLine(d2)) return false
+    return stripParamNames(d1) == stripParamNames(d2)
+}
+
+/**
+ * GirElements contains an attribute `introspectable`, which is a GirBoolean.
+ * If this is attribute is falsy the element is not introspectable,
+ * this means doesn't exist in the bindings, due in general to missing information in the annotations in the original C code
+ */
+export const girElementIsIntrospectable = (girElement?: { $: GirInfoAttrs & { name: string } }, name?: string) => {
+    if (!girElement) {
+        return false
+    }
+    name = name || girElement?.$?.name
+    if (!name) {
+        return false
+    }
+    // Handle introspectable only if the attribute is also present...
+    if (girElement.$.hasOwnProperty('introspectable') && girElement.$.introspectable !== undefined) {
+        return girBool(girElement.$.introspectable, true)
+    }
+    // ...otherwise we assume that it is introspectable
+    return true
+}
+
+export const typeIsOptional = (types: TsType[]) => {
+    for (const type of types) {
+        if (type.optional) return true
+    }
+    return false
+}