@ts-for-gir/cli 3.0.0-beta.9 → 3.0.0

package/lib/conflict-resolver.d.ts

@@ -1,155 +0,0 @@
-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;
-}