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

package/src/types/parsed-gir.ts

@@ -0,0 +1,5 @@
+import type { GirXML, GirRepository } from '@gi.ts/parser'
+
+export interface ParsedGir extends GirXML {
+    repository: GirRepository[]
+}

package/src/types/parsed-package-data.ts

@@ -0,0 +1,7 @@
+import type { PackageSectionParsed } from './index.ts'
+
+export interface ParsedPackageData {
+    packages: {
+        section: PackageSectionParsed[]
+    }
+}

package/src/types/property-case.ts

@@ -0,0 +1 @@
+export type PropertyCase = 'both' | 'camel' | 'underscore'

package/src/types/resolve-type.ts

@@ -0,0 +1,4 @@
+export enum ResolveType {
+    DEPENDENCE,
+    BY_HAND,
+}

package/src/types/template-data.ts

@@ -0,0 +1,8 @@
+import type { Data } from 'ejs'
+import type { OptionsGeneration } from './options-generation.ts'
+import type { GirModule } from '../gir-module.ts'
+
+export interface TemplateData extends Data, Partial<OptionsGeneration> {
+    girModule?: GirModule
+    importName?: string
+}

package/src/types/template-options.ts

@@ -0,0 +1,33 @@
+import type ejs from "ejs";
+
+/**
+ * Configuration options for template rendering
+ */
+export interface TemplateRenderOptions {
+	/** EJS rendering options */
+	ejsOptions?: Partial<ejs.Options>;
+	/** Whether to include append templates */
+	includeAppend?: boolean;
+	/** Custom template directory override */
+	templateDir?: string;
+}
+
+/**
+ * Result of template loading operation
+ */
+export interface TemplateLoadResult {
+	/** Main template content */
+	prepend: string;
+	/** Append template content (if exists) */
+	append: string;
+}
+
+/**
+ * Template file processing result
+ */
+export interface TemplateFileResult {
+	/** The rendered template content */
+	content: string;
+	/** The output file path */
+	outputPath: string;
+} 

package/src/types/transformation-case.ts

@@ -0,0 +1,9 @@
+export type TransformationCase =
+    | 'original'
+    | 'lowerCamelCase'
+    | 'upperCamelCase'
+    | 'upperCase'
+    | 'lowerCase'
+    | 'underscores'
+    | 'snakeCase'
+    | 'slugCase'

package/src/types/transformations.ts

@@ -0,0 +1,5 @@
+import type { TransformationCase } from './transformation-case.ts'
+
+export interface Transformations {
+    [type: string]: TransformationCase
+}

package/{lib/types/ts-doc-tag.d.ts → src/types/ts-doc-tag.ts}

@@ -9,13 +9,15 @@ export interface TsDocTag {
     /**
      * The name of this tag.
      */
-    tagName: string;
+    tagName: string
+
     /**
      * The name of the related parameter when this is a ```@param``` tag.
      */
-    paramName: string;
+    paramName: string
+
     /**
      * The actual body text of this tag.
      */
-    text: string;
+    text: string
 }

package/{lib/types/ts-doc.d.ts → src/types/ts-doc.ts}

@@ -1,4 +1,5 @@
-import type { TsDocTag } from './ts-doc-tag.js';
+import type { TsDocTag } from './ts-doc-tag.ts'
+
 /**
  * A model that represents a comment.
  *
@@ -8,9 +9,10 @@ export interface TsDoc {
     /**
      * The full body text of the comment..
      */
-    text: string;
+    text: string
+
     /**
      * All associated tags.
      */
-    tags: TsDocTag[];
+    tags: TsDocTag[]
 }

package/{lib/types/type-gir-alias.d.ts → src/types/type-gir-alias.ts}

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

package/{lib/types/type-gir-class.d.ts → src/types/type-gir-class.ts}

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

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

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

package/{lib/types/type-gir-enumeration-member.d.ts → src/types/type-gir-enumeration-member.ts}

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

package/{lib/types/type-ts-enumeration-member.d.ts → src/types/type-gir-enumeration.ts}

@@ -1,2 +1,2 @@
 /** All gir elements which can be a typescript enumeration */
-export type TypeTsEnumerationMember = 'enum-member';
+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/{lib/types/type-gir-interface.d.ts → src/types/type-gir-interface.ts}

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

package/{lib/types/type-gir-method.d.ts → src/types/type-gir-method.ts}

@@ -1,2 +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';
+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/{lib/types/type-gir-property.d.ts → src/types/type-gir-property.ts}

@@ -1,2 +1,2 @@
 /** All gir elements which can be a typescript field / property */
-export type TypeGirProperty = 'property' | 'field' | 'constant';
+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 type { TypeTsFunction, TypeTsProperty } from './index.ts'
+
+/** Any typescript element type */
+export type TypeTsElement =
+    | 'class'
+    | 'interface'
+    | 'enum'
+    | 'enum-member'
+    | 'constant'
+    | 'event-methods'
+    | 'type'
+    | TypeTsFunction
+    | TypeTsProperty

package/{lib/types/type-gir-enumeration.d.ts → src/types/type-ts-enumeration-member.ts}

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

package/{lib/types/type-ts-function.d.ts → src/types/type-ts-function.ts}

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

package/{lib/types/type-ts-property.d.ts → src/types/type-ts-property.ts}

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

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

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

package/{lib/types/user-config.d.ts → src/types/user-config.ts}

@@ -3,31 +3,31 @@
  */
 export interface UserConfig {
     /** root / working directory of your project */
-    root: string;
+    root: string
     /** directory to output to */
-    outdir: string | null;
+    outdir: string | null
     /** GIR directories */
-    girDirectories: string[];
+    girDirectories: string[]
     /** Switch on/off the verbose mode */
-    verbose: boolean;
+    verbose: boolean
     /** Do not ask for package versions if multiple versions are found */
-    ignoreVersionConflicts: boolean;
+    ignoreVersionConflicts: boolean
     /** print the output to console and create no files */
-    print: boolean;
+    print: boolean
     /** GIR modules to load, e.g. 'Gio-2.0'. Accepts multiple modules */
-    modules: string[];
+    modules: string[]
     /** modules that should be ignored */
-    ignore?: string[];
+    ignore?: string[]
     /** Do not export all symbols for each module as a namespace */
-    noNamespace: boolean;
+    noNamespace: boolean
     /** Do not generate documentation comments */
-    noComments: boolean;
+    noComments: boolean
     /** Generate promisified functions for async/finish calls */
-    promisify: boolean;
+    promisify: boolean
     /** Scope of the generated NPM packages */
-    npmScope: string;
+    npmScope: string
     /** Uses the workspace protocol for the generated packages which can be used with package managers like Yarn and PNPM */
-    workspace: boolean;
+    workspace: boolean
     /**
      * Only use the version prefix for the ambient module exports.
      * This is useful if, for whatever reason, you want to use different library versions of the same library in your project.
@@ -38,13 +38,21 @@ export interface UserConfig {
      * declare module 'gi://Gtk?version=3.0' {...}
      * ```
      */
-    onlyVersionPrefix: boolean;
+    onlyVersionPrefix: boolean
     /** Do not prettify the generated types */
-    noPrettyPrint: boolean;
+    noPrettyPrint: boolean
     /** Disable GLib.Variant class with string parsing */
-    noAdvancedVariants: boolean;
+    noAdvancedVariants: boolean
     /**
      * Generate the typescript types with package.json support
      */
-    package: boolean;
+    package: boolean
+    /**
+     * Enable generation problem reporter and create a detailed report file
+     */
+    reporter: boolean
+    /**
+     * Output file path for the reporter
+     */
+    reporterOutput: string
 }

package/src/util.ts

@@ -0,0 +1,84 @@
+/**
+ * A simple two-key map.
+ */
+export class TwoKeyMap<K1, K2, V> {
+	private baseMap = new Map<K1, Map<K2, V>>();
+
+	forEach(op: (v: V) => void) {
+		this.baseMap.forEach((map) => {
+			map.forEach((v) => {
+				op(v);
+			});
+		});
+	}
+
+	has(key1: K1, key2: K2): boolean {
+		const obj = this.baseMap.get(key1);
+
+		if (!obj) {
+			return false;
+		}
+
+		return obj.has(key2);
+	}
+
+	getIfOnly(key1: K1): readonly [K2, V] | undefined {
+		const obj = this.baseMap.get(key1);
+
+		if (!obj) {
+			return undefined;
+		}
+
+		if (obj.size === 1) {
+			const [k2] = obj.keys();
+			const v = obj.get(k2);
+
+			if (!v) {
+				return undefined;
+			}
+
+			return [k2, v] as const;
+		}
+
+		return undefined;
+	}
+
+	get(key1: K1, key2: K2): V | undefined {
+		const obj = this.baseMap.get(key1);
+
+		if (!obj) {
+			return undefined;
+		}
+
+		return obj.get(key2);
+	}
+
+	set(key1: K1, key2: K2, value: V): void {
+		let obj = this.baseMap.get(key1);
+
+		if (!obj) {
+			obj = new Map<K2, V>();
+
+			this.baseMap.set(key1, obj);
+		}
+
+		obj.set(key2, value);
+	}
+}
+
+/**
+ * If the predicate returns a value other than undefined,
+ * that value is returned. It combines the .find() and
+ * .map() APIs for convenience.
+ *
+ * @param arr
+ * @param predicate
+ */
+export function findMap<T, K>(arr: T[], predicate: (p: T) => K | undefined): K | undefined {
+	for (const a of arr) {
+		const val = predicate(a);
+		if (val !== undefined) return val;
+	}
+
+	return undefined;
+}

package/src/utils/conflicts/conflict-resolver.ts

@@ -0,0 +1,122 @@
+import type { IntrospectedClassMember } from "../../gir/introspected-class-member.ts";
+import type { IntrospectedBaseClass, IntrospectedClassFunction } from "../../gir/introspected-classes.ts";
+import type { IntrospectedNamespace } from "../../gir/namespace.ts";
+import { IntrospectedProperty } from "../../gir/property.ts";
+import type { TypeIdentifier } from "../../gir.ts";
+import { ConflictType, TypeConflict } from "../../gir.ts";
+
+/**
+ * Detects what type of conflict a class member has, if any
+ */
+export function detectConflictType<
+	T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty,
+>(
+	namespace: IntrospectedNamespace,
+	clazz: IntrospectedBaseClass,
+	element: T,
+	thisType: TypeIdentifier,
+): ConflictType | undefined {
+	// Check field conflicts
+	const fieldConflict = checkFieldConflicts(clazz, element);
+	if (fieldConflict) {
+		return fieldConflict;
+	}
+
+	// Check property conflicts
+	const propertyConflict = checkPropertyConflicts(namespace, clazz, element, thisType);
+	if (propertyConflict) {
+		return propertyConflict;
+	}
+
+	// Check function name conflicts
+	return checkFunctionNameConflicts(namespace, clazz, element, thisType);
+}
+
+/**
+ * Creates a conflict element wrapper for the given element
+ */
+export function createConflictElement<
+	T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty,
+>(element: T, conflictType: ConflictType): T | null {
+	if (element instanceof IntrospectedProperty) {
+		const conflictProperty = element.copy();
+		conflictProperty.type = new TypeConflict(conflictProperty.type, conflictType);
+		return conflictProperty as T;
+	}
+
+	// For other types, we might need to implement specific conflict handling
+	// For now, return the original element
+	return element;
+}
+
+function checkFieldConflicts<T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty>(
+	clazz: IntrospectedBaseClass,
+	element: T,
+): ConflictType | undefined {
+	if (!element.name) {
+		return undefined;
+	}
+
+	const hasFieldConflict = clazz.fields.some((field) => field.name === element.name);
+
+	if (hasFieldConflict) {
+		if (element instanceof IntrospectedProperty) {
+			return ConflictType.PROPERTY_NAME_CONFLICT;
+		}
+		return ConflictType.FIELD_NAME_CONFLICT;
+	}
+
+	return undefined;
+}
+
+function checkPropertyConflicts<T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty>(
+	_namespace: IntrospectedNamespace,
+	clazz: IntrospectedBaseClass,
+	element: T,
+	_thisType: TypeIdentifier,
+): ConflictType | undefined {
+	if (!element.name) {
+		return undefined;
+	}
+
+	const hasPropertyConflict = clazz.props.some((property) => property.name === element.name && property !== element);
+
+	if (hasPropertyConflict) {
+		// Check if this is an accessor property conflict
+		if (isAccessorProperty(element)) {
+			return ConflictType.ACCESSOR_PROPERTY_CONFLICT;
+		}
+		return ConflictType.PROPERTY_ACCESSOR_CONFLICT;
+	}
+
+	return undefined;
+}
+
+function checkFunctionNameConflicts<
+	T extends IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty,
+>(
+	_namespace: IntrospectedNamespace,
+	clazz: IntrospectedBaseClass,
+	element: T,
+	_thisType: TypeIdentifier,
+): ConflictType | undefined {
+	if (!element.name) {
+		return undefined;
+	}
+
+	const hasFunctionConflict = clazz.members.some((member) => member.name === element.name && member !== element);
+
+	if (hasFunctionConflict) {
+		return ConflictType.FUNCTION_NAME_CONFLICT;
+	}
+
+	return undefined;
+}
+
+function isAccessorProperty(
+	element: IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty,
+): boolean {
+	// Check if the element is an accessor property
+	// This is a simplified check - in practice, you might need more sophisticated logic
+	return element instanceof IntrospectedProperty && element.readable && element.writable;
+}

package/src/utils/conflicts/function-conflict-detector.ts

@@ -0,0 +1,139 @@
+import { IntrospectedConstructor } from "../../gir/constructor.ts";
+import type { IntrospectedFunction } from "../../gir/function.ts";
+import type { IntrospectedClassFunction } from "../../gir/introspected-classes.ts";
+import type { IntrospectedNamespace } from "../../gir/namespace.ts";
+import type { IntrospectedFunctionParameter } from "../../gir/parameter.ts";
+import type { TypeIdentifier } from "../../gir.ts";
+import { isSubtypeOf } from "../type-resolution.ts";
+
+/**
+ * Checks if two functions are conflicting based on their signatures
+ */
+export function isConflictingFunction(
+	namespace: IntrospectedNamespace,
+	childThis: TypeIdentifier,
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parentThis: TypeIdentifier,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	if (!parent.isIntrospectable || !child.isIntrospectable) {
+		return false;
+	}
+
+	// Handle constructor conflicts
+	if (isConstructorConflict(namespace, childThis, child, parentThis, parent)) {
+		return true;
+	}
+
+	// Handle mixed constructor/function conflicts
+	if (isMixedConstructorFunctionConflict(child, parent)) {
+		return true;
+	}
+
+	// Handle different function types (no conflict if different prototypes)
+	if (hasDifferentPrototypes(child, parent)) {
+		return false;
+	}
+
+	// Check parameter and return type conflicts
+	return hasParameterOrReturnTypeConflicts(namespace, childThis, child, parentThis, parent);
+}
+
+function isConstructorConflict(
+	namespace: IntrospectedNamespace,
+	childThis: TypeIdentifier,
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parentThis: TypeIdentifier,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	if (!(child instanceof IntrospectedConstructor && parent instanceof IntrospectedConstructor)) {
+		return false;
+	}
+
+	return (
+		child.parameters.length > parent.parameters.length ||
+		!isSubtypeOf(namespace, childThis, parentThis, child.return(), parent.return()) ||
+		child.parameters.some((p, i) => !isSubtypeOf(namespace, childThis, parentThis, p.type, parent.parameters[i].type))
+	);
+}
+
+function isMixedConstructorFunctionConflict(
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	return child instanceof IntrospectedConstructor !== parent instanceof IntrospectedConstructor;
+}
+
+function hasDifferentPrototypes(
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	// This occurs if two functions of the same name are passed but they
+	// are different types (e.g. GirStaticClassFunction vs GirClassFunction)
+	return Object.getPrototypeOf(child) !== Object.getPrototypeOf(parent);
+}
+
+function hasParameterOrReturnTypeConflicts(
+	namespace: IntrospectedNamespace,
+	childThis: TypeIdentifier,
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parentThis: TypeIdentifier,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	// Check basic parameter conflicts
+	if (child.parameters.length > parent.parameters.length) {
+		return true;
+	}
+
+	// Check return type conflicts
+	if (!isSubtypeOf(namespace, childThis, parentThis, child.return(), parent.return())) {
+		return true;
+	}
+
+	// Check parameter type conflicts
+	if (hasParameterTypeConflicts(namespace, childThis, child.parameters, parentThis, parent.parameters)) {
+		return true;
+	}
+
+	// Check output parameter conflicts if both functions support them
+	return hasOutputParameterConflicts(namespace, childThis, child, parentThis, parent);
+}
+
+function hasParameterTypeConflicts(
+	namespace: IntrospectedNamespace,
+	childThis: TypeIdentifier,
+	childParams: IntrospectedFunctionParameter[],
+	parentThis: TypeIdentifier,
+	parentParams: IntrospectedFunctionParameter[],
+): boolean {
+	return childParams.some(
+		(childParam, i) => !isSubtypeOf(namespace, childThis, parentThis, childParam.type, parentParams[i].type),
+	);
+}
+
+function hasOutputParameterConflicts(
+	namespace: IntrospectedNamespace,
+	childThis: TypeIdentifier,
+	child: IntrospectedFunction | IntrospectedClassFunction | IntrospectedConstructor,
+	parentThis: TypeIdentifier,
+	parent: IntrospectedClassFunction | IntrospectedFunction | IntrospectedConstructor,
+): boolean {
+	// Only check output parameters if both functions have them (constructors don't have output_parameters)
+	const childHasOutputParams = "output_parameters" in child;
+	const parentHasOutputParams = "output_parameters" in parent;
+
+	if (!childHasOutputParams || !parentHasOutputParams) {
+		return false;
+	}
+
+	// Length mismatch
+	if (child.output_parameters.length !== parent.output_parameters.length) {
+		return true;
+	}
+
+	// Type mismatch
+	return child.output_parameters.some(
+		(childParam, i) =>
+			!isSubtypeOf(namespace, childThis, parentThis, childParam.type, parent.output_parameters[i].type),
+	);
+}

package/src/utils/conflicts/index.ts

@@ -0,0 +1,2 @@
+export * from "./conflict-resolver.ts";
+export * from "./function-conflict-detector.ts";