@ts-for-gir/lib 3.0.0-beta.11

package/README.md

@@ -0,0 +1,22 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/gjsify/ts-for-gir/main/.github/ts-for-gir.png" />
+  <h1 align="center">TS <small>for</small> GIR</h1>
+</p>
+
+<p align="center">
+  <img src="https://badgen.net/github/checks/gjsify/ts-for-gir" />
+  <img src="https://badgen.net/github/license/gjsify/ts-for-gir" />
+  <img src="https://badgen.net/npm/v/@ts-for-gir/cli" />
+  <img src="https://badgen.net/npm/dw/@ts-for-gir/cli" />
+</p>
+
+<p align="center">TypeScript type definition generator for GObject introspection GIR files</p>
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/gjsify/ts-for-gir/main/.github/feeling.gif" />
+</p>
+
+# Library
+
+Node.js library to generate Typescript Type Definition files for Gjs and node-gtk.
+

package/lib/conflict-resolver.d.ts

@@ -0,0 +1,155 @@
+import type { Environment, GirClassElement, GirRecordElement, GirUnionElement, GirInterfaceElement, GirCallableParamElement, TsSignal, TsFunction, TsProperty, TsVar, TsTypeSeparator, TsType, TsClass, TypeGirFunction, TypeGirProperty, ConflictChildElement, ConflictGroupedElements, ConflictGroupedElement } from './types/index.js';
+/**
+ * Resolve conflicts between types caused by overloads / inheritances and implementations
+ * With multiple implementations or a inherit it can happen that the interfaces / parent have the same method and/or property names with incompatible types,
+ * we are trying to resolve this conflicts by merging, overloading or removing this conflicts.
+ */
+export declare class ConflictResolver {
+    private readonly environment;
+    private readonly verbose;
+    private log;
+    private girFactory;
+    constructor(environment: Environment, verbose: boolean);
+    private girElArrToChildArr;
+    private tsElArrToChildArr;
+    /**
+     * Get class elements and parent elements (implementations and inherits)
+     * @param tsClass
+     * @param depth
+     * @returns
+     */
+    private getClassElements;
+    private tsElementIsMethod;
+    private tsElementIsStaticFunction;
+    private tsElementIsProperty;
+    private tsElementIsStaticProperty;
+    private tsElementIsSignal;
+    private tsElementIsConstructor;
+    private tsElementIsMethodOrFunction;
+    private tsElementIsPropertyOrVariable;
+    private tsElementIsStatic;
+    private typeIsString;
+    private mergeTypes;
+    private setTypesProperty;
+    /**
+     * Merges two parameter name and type of two parameters
+     * @param a
+     * @param b
+     * @returns
+     */
+    private mergeParam;
+    /**
+     * Merges parameter names and types of multiple functions
+     * @param params
+     * @returns
+     */
+    private mergeParams;
+    private paramCanBeOptional;
+    /**
+     * In Typescript no optional parameters are allowed if the following ones are not optional
+     * @param girParams
+     * @returns
+     */
+    private fixOptionalParameters;
+    /**
+     * Merge function types and parameters together
+     * @param baseFunc The function to change or null if you want to create a new property
+     * @param funcs The functions you want to merge
+     * @returns
+     */
+    mergeFunctions(baseFunc: TsFunction | null, ...funcs: TsFunction[]): TsFunction;
+    /**
+     * Merge property types together
+     * @param baseProp The property to change or null if you want to create a new property
+     * @param props The properties you want to merge
+     * @returns
+     */
+    mergeProperties(typeSeparator: TsTypeSeparator, baseProp: TsProperty | null, ...props: TsProperty[]): TsProperty;
+    /**
+     * Check if there is a type conflict between the ts elements a and b
+     * @param a
+     * @param b
+     * @returns
+     */
+    hasConflict(a: ConflictChildElement, b: ConflictChildElement): boolean;
+    newAnyTsProperty(name: string, girTypeName: TypeGirProperty): TsProperty;
+    /**
+     * Returns a new any function: `name(...args: any[]): any`
+     * @param name The name of the function
+     */
+    newAnyTsFunction(name: string, girTypeName: TypeGirFunction, isStatic: boolean, parent: TsClass | null): TsFunction;
+    getCompatibleTsProperty(elements: TsProperty[], baseProp: TsProperty): TsProperty | undefined;
+    getCompatibleTsFunction(elements: TsFunction[], baseFunc: TsFunction): TsFunction | undefined;
+    /**
+     * Use this instead of `getCompatibleTsProperty` and `getCompatibleTsProperty` if you can, because it's much faster
+     * @param elements
+     * @param name
+     * @returns
+     */
+    getTsElementByName(elements: (TsProperty | TsFunction)[], name: string): TsFunction | TsProperty | undefined;
+    protected canAddConflictProperty(conflictProperties: TsProperty[], prop: TsProperty): boolean | "" | null;
+    groupSignalConflicts(signalsMethods: ConflictChildElement<TsFunction>[], baseClass: TsClass): ConflictGroupedElements<TsFunction | TsProperty | TsVar>;
+    fixSignalConflicts(groupedElements: ConflictGroupedElements): void;
+    /**
+     * Check conflicts between the implementations / inheritances
+     * To fix type errors like:
+     * ```
+     *   Interface 'PopoverMenu' can\'t simultaneously extend types 'Popover' and 'Native'.
+     *   Named property 'parent' of types 'Popover' and 'Native' are not identical.
+     */
+    fixIndirectConflicts(name: string, elements: ConflictChildElement[], baseClass: TsClass): void;
+    /**
+     * Check conflicts within the class itself (ignores implementations / inheritances)
+     */
+    fixInternalConflicts(name: string, elements: ConflictChildElement[], baseClass: TsClass): void;
+    /**
+     * Check conflicts of the class with implementations and inheritances
+     */
+    fixDirectConflicts(name: string, elements: ConflictGroupedElement): void;
+    /**
+     * Fix the conflicts of a class
+     * @param groupedElements
+     */
+    fixConflicts(groupedElements: ConflictGroupedElements): void;
+    /**
+     * Group conflicts by name and sort them by depth for simpler handling of conflicts
+     */
+    groupConflicts(elements: ConflictChildElement[], tsClass: TsClass): ConflictGroupedElements<TsFunction | TsProperty | TsVar>;
+    /**
+     * With multiple implementations or a inherit it can happen that the interfaces / parent have the same method and/or property name with incompatible types.
+     * We merge these types here to solve this problem.
+     * @param girClass
+     */
+    repairClass(girClass: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement): GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement;
+    /**
+     * Returns true if `p1s` and `p2s` conflicting with each other.
+     * The parameters must have the same length and the same type but can have different names
+     * @param params
+     * @returns
+     */
+    paramsHasConflict(...params: GirCallableParamElement[][]): boolean;
+    typesHasConflict(a: TsType[], b: TsType[]): boolean;
+    /**
+     * Returns `true` if the function / method types of `a` and `b` are not compatible with each other.
+     * The parameters must have the same length and the same type but can have different names
+     * @param a
+     * @param b
+     * @returns
+     */
+    functionHasConflict(a: TsFunction, b: TsFunction): boolean;
+    /**
+     * Returns `true` if the property types of `a` and `b` are not compatible with each other.
+     * @param a
+     * @param b
+     * @returns
+     */
+    propertyHasConflict(a: TsVar & TsProperty, b: TsVar & TsProperty): boolean;
+    signalHasConflict(a: TsSignal, b: TsSignal): boolean;
+    /**
+     * Returns true if the elements (properties or methods) of `a` and `b` are not compatible with each other (has no conflict).
+     * @param a
+     * @param b
+     * @returns
+     */
+    elementHasConflict(a: TsFunction | TsVar | TsProperty | TsSignal, b: TsFunction | TsVar | TsProperty | TsSignal): boolean;
+}