@ts-for-gir/lib 4.0.0-beta.3 → 4.0.0-beta.31

package/src/gir/constructor.ts

@@ -0,0 +1,91 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import { type Generic, type TypeExpression, UnknownType } from "../gir.ts";
+import type { GirConstructorElement, GirFunctionElement } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedClassMember } from "./introspected-class-member.ts";
+import type { IntrospectedBaseClass } from "./introspected-classes.ts";
+import { IntrospectedClassFunction } from "./introspected-classes.ts";
+import type { IntrospectedFunctionParameter } from "./parameter.ts";
+
+export class IntrospectedConstructor extends IntrospectedClassMember {
+	readonly parameters: IntrospectedFunctionParameter[] = [];
+	readonly return_type: TypeExpression = UnknownType;
+
+	generics: Generic[] = [];
+
+	constructor({
+		name,
+		parameters = [],
+		return_type,
+		parent,
+		...args
+	}: IntrospectedOptions<{
+		name: string;
+		parent: IntrospectedBaseClass | null;
+		parameters?: IntrospectedFunctionParameter[];
+		return_type: TypeExpression;
+	}>) {
+		super(name, parent, { ...args });
+		this.return_type = return_type;
+		this.parameters = parameters.map((p) => p.copy({ parent: this }));
+	}
+
+	copy({
+		parent,
+		parameters,
+		return_type,
+	}: {
+		parent?: IntrospectedBaseClass;
+		parameters?: IntrospectedFunctionParameter[];
+		return_type?: TypeExpression;
+	} = {}): IntrospectedConstructor {
+		const constr = new IntrospectedConstructor({
+			name: this.name,
+			parent: parent ?? this.parent ?? null,
+			return_type: return_type ?? this.return_type,
+			parameters: parameters ?? this.parameters,
+		})._copyBaseProperties(this);
+
+		constr.generics = [...this.generics];
+
+		return constr;
+	}
+
+	static fromXML(
+		m: GirConstructorElement,
+		parent: IntrospectedBaseClass,
+		options: OptionsLoad,
+	): IntrospectedConstructor {
+		const fn = IntrospectedClassFunction.fromXML(m as GirFunctionElement, parent, options);
+
+		// Convert the class function to a constructor
+		// Always force constructors to have the correct return type.
+		return new IntrospectedConstructor({
+			name: fn.name,
+			parent,
+			parameters: fn.parameters,
+			return_type: parent.getType(),
+			isIntrospectable: fn.isIntrospectable,
+		});
+	}
+
+	accept(visitor: GirVisitor): IntrospectedConstructor {
+		const node = this.copy({
+			parameters: this.parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			return_type: visitor.visitType?.(this.return_type),
+		});
+
+		return visitor.visitConstructor?.(node) ?? node;
+	}
+
+	return() {
+		return this.return_type;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateConstructor"]> {
+		return generator.generateConstructor(this) as ReturnType<T["generateConstructor"]>;
+	}
+}

package/src/gir/data.ts

@@ -0,0 +1,12 @@
+export enum ClassInjectionMember {
+	MEMBER = "member",
+	CONSTRUCTOR = "_constructor",
+	PROPERTY = "prop",
+	FIELD = "field",
+	MAIN_CONSTRUCTOR = "constructor",
+}
+
+export enum FilterBehavior {
+	DELETE,
+	PRESERVE,
+}

package/src/gir/dependency-resolver.ts

@@ -0,0 +1,81 @@
+import type { DependencyManager } from "../dependency-manager.ts";
+import type { Dependency } from "../types/index.ts";
+import { find } from "../utils/objects.ts";
+
+/**
+ * Handles resolution and validation of GIR module dependencies
+ */
+export class DependencyResolver {
+	private readonly dependencyManager: DependencyManager;
+
+	constructor(dependencyManager: DependencyManager) {
+		this.dependencyManager = dependencyManager;
+	}
+
+	/**
+	 * Resolves transitive dependencies and adds missing required dependencies
+	 */
+	async resolveTransitiveDependencies(
+		packageName: string,
+		transitiveDependencies: Dependency[],
+	): Promise<Dependency[]> {
+		// Always pull in GObject-2.0, as we may need it for e.g. GObject-2.0.type
+		if (packageName !== "GObject-2.0") {
+			this.ensureGObjectDependency(transitiveDependencies);
+		}
+
+		// Add package-specific missing dependencies
+		this.addPackageSpecificDependencies(packageName, transitiveDependencies);
+
+		return transitiveDependencies;
+	}
+
+	private ensureGObjectDependency(transitiveDependencies: Dependency[]): void {
+		if (!this.hasDependency(transitiveDependencies, "GObject-2.0")) {
+			transitiveDependencies.push(this.getDependency("GObject", "2.0"));
+		}
+	}
+
+	private addPackageSpecificDependencies(packageName: string, transitiveDependencies: Dependency[]): void {
+		const dependencyRules = this.getDependencyRules();
+		const rule = dependencyRules[packageName];
+
+		if (rule) {
+			rule.forEach(({ namespace, version }) => {
+				const requiredPackage = `${namespace}-${version}`;
+				if (!this.hasDependency(transitiveDependencies, requiredPackage)) {
+					transitiveDependencies.push(this.getDependency(namespace, version));
+				}
+			});
+		}
+	}
+
+	private getDependencyRules(): Record<string, Array<{ namespace: string; version: string; required: string }>> {
+		return {
+			"UnityExtras-7.0": [{ namespace: "Unity", version: "7.0", required: "Unity-7.0" }],
+			"UnityExtras-6.0": [{ namespace: "Unity", version: "6.0", required: "Unity-6.0" }],
+			"GTop-2.0": [{ namespace: "GLib", version: "2.0", required: "GLib-2.0" }],
+			"GioUnix-2.0": [
+				{ namespace: "Gio", version: "2.0", required: "Gio-2.0" },
+				{ namespace: "GLib", version: "2.0", required: "GLib-2.0" },
+			],
+		};
+	}
+
+	private hasDependency(dependencies: Dependency[], packageName: string): boolean {
+		return find(dependencies, (x) => x.packageName === packageName) !== undefined;
+	}
+
+	private getDependency(namespace: string, version: string): Dependency {
+		// This will be resolved asynchronously - for now, we'll use a placeholder
+		// In the actual implementation, this should call this.dependencyManager.get(namespace, version)
+		throw new Error(`Dependency resolution for ${namespace}-${version} needs to be implemented asynchronously`);
+	}
+
+	/**
+	 * Asynchronously gets a dependency - this method should be used instead of getDependency
+	 */
+	async getDependencyAsync(namespace: string, version: string): Promise<Dependency> {
+		return await this.dependencyManager.get(namespace, version);
+	}
+}

package/src/gir/direct-allocation-constructor.ts

@@ -0,0 +1,65 @@
+import { GirDirection } from "@gi.ts/parser";
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedClassMember } from "./introspected-class-member.ts";
+import type { IntrospectedBaseClass } from "./introspected-classes.ts";
+import { IntrospectedFunctionParameter } from "./parameter.ts";
+import type { IntrospectedField } from "./property.ts";
+
+export class IntrospectedDirectAllocationConstructor extends IntrospectedClassMember {
+	parameters: IntrospectedFunctionParameter[];
+
+	constructor(parameters: IntrospectedFunctionParameter[], parent: IntrospectedBaseClass | null) {
+		super("new", parent, { isPrivate: false, isIntrospectable: true });
+
+		this.parameters = parameters.map((parameter) => parameter.copy({ parent: this }));
+	}
+
+	static fromFields(fields: IntrospectedField[], parent: IntrospectedBaseClass) {
+		const building = new IntrospectedDirectAllocationConstructor([], parent);
+
+		building.parameters = fields
+			.filter((field) => {
+				return !field.isStatic && !field.isPrivate && !field.type.isPointer;
+			})
+			.map(
+				(field) =>
+					new IntrospectedFunctionParameter({
+						parent: building,
+						type: field.type,
+						name: field.name,
+						direction: GirDirection.In,
+					}),
+			);
+
+		return building;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateDirectAllocationConstructor"]> {
+		return generator.generateDirectAllocationConstructor(this) as ReturnType<T["generateDirectAllocationConstructor"]>;
+	}
+
+	copy(options?: {
+		parent?: IntrospectedBaseClass | undefined;
+		parameters?: IntrospectedFunctionParameter[];
+	}): IntrospectedDirectAllocationConstructor {
+		const copy = new IntrospectedDirectAllocationConstructor(
+			options?.parameters ?? this.parameters,
+			options?.parent ?? this.parent,
+		);
+
+		copy._copyBaseProperties(this);
+
+		return copy;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedDirectAllocationConstructor {
+		const node = this.copy({
+			parameters: this.parameters.map((parameters) => {
+				return parameters.accept(visitor);
+			}),
+		});
+
+		return visitor.visitDirectAllocationConstructor?.(node) ?? node;
+	}
+}

package/src/gir/enum-member.ts

@@ -0,0 +1,51 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { GirMemberElement } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import type { GirVisitor } from "../visitor.ts";
+import type { IntrospectedEnum } from "./enum.ts";
+import { IntrospectedBase } from "./introspected-base.ts";
+
+export class GirEnumMember extends IntrospectedBase<IntrospectedEnum> {
+	value: string;
+	c_identifier: string;
+
+	constructor(name: string, value: string, parent: IntrospectedEnum, c_identifier: string) {
+		super(name, parent);
+		this.value = value;
+		this.c_identifier = c_identifier;
+	}
+
+	get namespace() {
+		return this.parent.namespace;
+	}
+
+	accept(visitor: GirVisitor): GirEnumMember {
+		const node = this.copy();
+		return visitor.visitEnumMember?.(node) ?? node;
+	}
+
+	copy(): GirEnumMember {
+		const { value, name, parent, c_identifier } = this;
+
+		return new GirEnumMember(name, value, parent, c_identifier)._copyBaseProperties(this);
+	}
+
+	static fromXML(element: GirMemberElement, parent: IntrospectedEnum, options: OptionsLoad): GirEnumMember {
+		const upper = element.$.name.toUpperCase();
+		const c_identifier = element.$["c:identifier"];
+
+		const enumMember = new GirEnumMember(upper, element.$.value, parent, c_identifier);
+
+		if (options.loadDocs) {
+			enumMember.doc = parseDoc(element);
+			enumMember.metadata = parseMetadata(element);
+		}
+
+		return enumMember;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateEnumMember"]> {
+		return generator.generateEnumMember(this) as ReturnType<T["generateEnumMember"]>;
+	}
+}

package/src/gir/enum.ts

@@ -0,0 +1,126 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import { NumberType, TypeIdentifier } from "../gir.ts";
+import type { GirBitfieldElement, GirEnumElement } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { sanitizeIdentifierName, sanitizeMemberName } from "../utils/naming.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { GirEnumMember } from "./enum-member.ts";
+import { GirComplexRecord } from "./gir-complex-record.ts";
+import { IntrospectedNamespaceMember } from "./introspected-namespace-member.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+import { IntrospectedField } from "./property.ts";
+import type { IntrospectedRecord } from "./record.ts";
+
+export class IntrospectedEnum extends IntrospectedNamespaceMember {
+	members = new Map<string, GirEnumMember>();
+	flags: boolean = false;
+	ns: IntrospectedNamespace;
+
+	constructor(name: string, namespace: IntrospectedNamespace, options: { isIntrospectable?: boolean } = {}) {
+		super(sanitizeIdentifierName(namespace.namespace, name), namespace, options);
+
+		this.ns = namespace;
+	}
+
+	copy({ members }: { parent?: undefined; members?: Map<string, GirEnumMember> } = {}): IntrospectedEnum {
+		const { namespace, name, flags } = this;
+
+		const en = new IntrospectedEnum(name, namespace);
+
+		for (const [key, member] of (members ?? this.members).entries()) {
+			en.members.set(key, member.copy());
+		}
+
+		en.flags = flags;
+
+		en._copyBaseProperties(this);
+
+		return en;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedEnum {
+		const node = this.copy({
+			members: new Map(
+				Array.from(this.members.entries()).map(([name, m]) => {
+					return [name, m.accept(visitor)];
+				}),
+			),
+		});
+
+		return visitor.visitEnum?.(node) ?? node;
+	}
+
+	getType(): TypeIdentifier {
+		return new TypeIdentifier(this.name, this.ns.namespace);
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateEnum"]> {
+		return generator.generateEnum(this) as ReturnType<T["generateEnum"]>;
+	}
+
+	asClass(): IntrospectedRecord {
+		const { name, namespace, doc } = this;
+
+		const clazz = new GirComplexRecord({ name, namespace, doc });
+
+		clazz.fields.push(
+			...Array.from(this.members.values()).map((m) => {
+				const field = new IntrospectedField({
+					name: m.name,
+					parent: clazz,
+					type: NumberType,
+					writable: true,
+					isStatic: true,
+				});
+
+				field.doc = m.doc;
+				field.metadata = m.metadata;
+
+				return field;
+			}),
+		);
+		clazz.members = [];
+		return clazz;
+	}
+
+	static fromXML(
+		element: GirEnumElement | GirBitfieldElement,
+		ns: IntrospectedNamespace,
+		options: OptionsLoad,
+		flags = false,
+	): IntrospectedEnum {
+		const em = new IntrospectedEnum(sanitizeMemberName(element.$.name), ns);
+
+		if (element.$["glib:type-name"]) {
+			em.resolve_names.push(element.$["glib:type-name"]);
+
+			ns.registerResolveName(element.$["glib:type-name"], ns.namespace, em.name);
+		}
+
+		if (element.$["c:type"]) {
+			em.resolve_names.push(element.$["c:type"]);
+
+			ns.registerResolveName(element.$["c:type"], ns.namespace, em.name);
+		}
+
+		if (options.loadDocs) {
+			em.doc = parseDoc(element);
+			em.metadata = parseMetadata(element);
+		}
+
+		if (!element.member) {
+			return em;
+		}
+
+		element.member.forEach((m) => {
+			const member = GirEnumMember.fromXML(m, em, options);
+
+			em.members.set(member.name, member);
+		});
+
+		em.flags = flags;
+
+		return em;
+	}
+}

package/src/gir/error.ts

@@ -0,0 +1,82 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { GirBitfieldElement, GirEnumElement } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { sanitizeMemberName } from "../utils/naming.ts";
+import { IntrospectedEnum } from "./enum.ts";
+import { GirEnumMember } from "./enum-member.ts";
+import { IntrospectedStaticClassFunction } from "./introspected-classes.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+// TODO: Move to utils
+function isEnumElement(e: unknown): e is GirEnumElement {
+	return typeof e === "object" && e != null && "function" in e;
+}
+
+export class IntrospectedError extends IntrospectedEnum {
+	functions: Map<string, IntrospectedStaticClassFunction> = new Map();
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateError"]> {
+		return generator.generateError(this) as ReturnType<T["generateError"]>;
+	}
+
+	copy({ members }: { parent?: undefined; members?: Map<string, GirEnumMember> } = {}): IntrospectedEnum {
+		const { namespace, name, flags } = this;
+
+		const en = new IntrospectedError(name, namespace);
+
+		for (const [key, member] of (members ?? this.members).entries()) {
+			en.members.set(key, member.copy());
+		}
+
+		for (const [key, func] of this.functions.entries()) {
+			en.functions.set(key, func.copy({ parent: en }));
+		}
+
+		en.flags = flags;
+
+		return en._copyBaseProperties(this);
+	}
+
+	static fromXML(
+		element: GirEnumElement | GirBitfieldElement,
+		ns: IntrospectedNamespace,
+		options: OptionsLoad,
+	): IntrospectedEnum {
+		const err = new IntrospectedError(sanitizeMemberName(element.$.name), ns);
+
+		if (element.$["glib:type-name"]) {
+			err.resolve_names.push(element.$["glib:type-name"]);
+
+			ns.registerResolveName(element.$["glib:type-name"], ns.namespace, err.name);
+		}
+
+		if (element.$["c:type"]) {
+			err.resolve_names.push(element.$["c:type"]);
+
+			ns.registerResolveName(element.$["c:type"], ns.namespace, err.name);
+		}
+
+		if (options.loadDocs) {
+			err.doc = parseDoc(element);
+			err.metadata = parseMetadata(element);
+		}
+
+		if (element.member) {
+			element.member.forEach((m) => {
+				const member = GirEnumMember.fromXML(m, err, options);
+				err.members.set(member.name, member);
+			});
+		}
+
+		if (isEnumElement(element) && element.function) {
+			element.function.forEach((f) => {
+				const func = IntrospectedStaticClassFunction.fromXML(f, err, options);
+				err.functions.set(func.name, func);
+			});
+		}
+
+		return err;
+	}
+}