@ts-for-gir/lib 4.0.0-beta.4 → 4.0.0-beta.40

package/src/gir/alias.ts

@@ -0,0 +1,73 @@
+import type { FormatGenerator, GenericDescriptor } from "../generators/generator.ts";
+import type { TypeExpression } from "../gir.ts";
+import type { GirAliasElement } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import { parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { isIntrospectable } from "../utils/girs.ts";
+import { sanitizeIdentifierName } from "../utils/naming.ts";
+import { getAliasType } from "../utils/types.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedNamespaceMember } from "./introspected-namespace-member.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+export class IntrospectedAlias extends IntrospectedNamespaceMember {
+	readonly type: TypeExpression;
+	readonly generics: GenericDescriptor[];
+
+	constructor({
+		namespace,
+		name,
+		type,
+		generics = [],
+		...args
+	}: IntrospectedOptions<{
+		namespace: IntrospectedNamespace;
+		name: string;
+		type: TypeExpression;
+		generics?: GenericDescriptor[];
+	}>) {
+		super(name, namespace, { ...args });
+
+		this.type = type;
+		this.generics = generics;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedAlias {
+		const node = this.copy({
+			type: visitor.visitType?.(this.type),
+		});
+
+		return visitor.visitAlias?.(node) ?? node;
+	}
+
+	copy(options?: { parent?: undefined; type?: TypeExpression }): IntrospectedAlias {
+		const { name, namespace, type } = this;
+
+		return new IntrospectedAlias({ name, namespace, type: options?.type ?? type })._copyBaseProperties(this);
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateAlias"]> {
+		return generator.generateAlias(this) as ReturnType<T["generateAlias"]>;
+	}
+
+	static fromXML(element: GirAliasElement, ns: IntrospectedNamespace, options: OptionsLoad): IntrospectedAlias | null {
+		if (!element.$.name) {
+			console.error(`Alias in ${ns.namespace} lacks name.`);
+			return null;
+		}
+
+		const alias = new IntrospectedAlias({
+			namespace: ns,
+			name: sanitizeIdentifierName(ns.namespace, element.$.name),
+			type: getAliasType(ns.namespace, ns, element),
+			isIntrospectable: isIntrospectable(element),
+		});
+
+		if (options.loadDocs) {
+			alias.doc = parseDoc(element);
+			alias.metadata = parseMetadata(element);
+		}
+
+		return alias;
+	}
+}

package/src/gir/callback.ts

@@ -0,0 +1,79 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import { FunctionType, type TypeExpression } from "../gir.ts";
+import type { GirCallbackElement, GirModule } from "../index.ts";
+import type { OptionsLoad } from "../types/index.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedFunction } from "./function.ts";
+import type { IntrospectedFunctionParameter } from "./parameter.ts";
+
+export class IntrospectedCallback extends IntrospectedFunction {
+	asFunctionType(): FunctionType {
+		return new FunctionType(
+			Object.fromEntries(this.parameters.map((p) => [p.name, p.type] as const)),
+			this.return_type,
+		);
+	}
+
+	copy({
+		parameters,
+		returnType,
+		outputParameters,
+		parent,
+	}: {
+		parent?: GirModule;
+		parameters?: IntrospectedFunctionParameter[];
+		outputParameters?: IntrospectedFunctionParameter[];
+		returnType?: TypeExpression;
+	} = {}): IntrospectedCallback {
+		const cb = new IntrospectedCallback({
+			name: this.name,
+			raw_name: this.raw_name,
+			return_type: returnType ?? this.return_type,
+			parameters: parameters ?? this.parameters,
+			output_parameters: outputParameters ?? this.output_parameters,
+			namespace: parent ?? this.parent,
+		})._copyBaseProperties(this);
+
+		cb.generics = [...this.generics];
+
+		return cb;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedCallback {
+		const node = this.copy({
+			parameters: this.parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			outputParameters: this.output_parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			returnType: visitor.visitType?.(this.return_type),
+		});
+
+		return visitor.visitCallback?.(node) ?? node;
+	}
+
+	static fromXML(element: GirCallbackElement, namespace: GirModule, options: OptionsLoad): IntrospectedCallback {
+		const ns = namespace;
+		const cb = new IntrospectedCallback(IntrospectedFunction.fromXML(element, ns, options).getCallbackParameters());
+
+		const glibTypeName = element.$["glib:type-name"];
+		if (typeof glibTypeName === "string" && element.$["glib:type-name"]) {
+			cb.resolve_names.push(glibTypeName);
+
+			ns.registerResolveName(glibTypeName, ns.namespace, cb.name);
+		}
+
+		if (element.$["c:type"]) {
+			cb.resolve_names.push(element.$["c:type"]);
+
+			ns.registerResolveName(element.$["c:type"], ns.namespace, cb.name);
+		}
+
+		return cb;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateCallback"]> {
+		return generator.generateCallback(this) as ReturnType<T["generateCallback"]>;
+	}
+}

package/src/gir/const.ts

@@ -0,0 +1,73 @@
+import type { FormatGenerator } from "../generators/generator.ts";
+import type { TypeExpression } from "../gir.ts";
+
+import type { GirConstantElement } from "../index.ts";
+import type { IntrospectedOptions, OptionsLoad } from "../types/index.ts";
+import { getType, parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { sanitizeIdentifierName } from "../utils/naming.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedNamespaceMember } from "./introspected-namespace-member.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+export class IntrospectedConstant extends IntrospectedNamespaceMember {
+	type: TypeExpression;
+	value: string | null;
+
+	constructor({
+		name,
+		type,
+		namespace,
+		value,
+		...options
+	}: IntrospectedOptions<{
+		name: string;
+		type: TypeExpression;
+		namespace: IntrospectedNamespace;
+		value: string | null;
+		isIntrospectable?: boolean;
+	}>) {
+		super(name, namespace, options);
+
+		this.type = type;
+		this.value = value;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedConstant {
+		const node = this.copy({
+			type: visitor.visitType?.(this.type),
+		});
+
+		return visitor.visitConst?.(node) ?? node;
+	}
+
+	copy(options: { parent?: IntrospectedNamespace; type?: TypeExpression } = {}): IntrospectedConstant {
+		const { type, name, value } = this;
+
+		return new IntrospectedConstant({
+			name,
+			namespace: options.parent ?? this.namespace,
+			type: options.type ?? type,
+			value,
+		})._copyBaseProperties(this);
+	}
+
+	static fromXML(element: GirConstantElement, ns: IntrospectedNamespace, options: OptionsLoad): IntrospectedConstant {
+		const c = new IntrospectedConstant({
+			name: sanitizeIdentifierName(ns.namespace, element.$.name),
+			namespace: ns,
+			type: getType(ns, element),
+			value: element.$.value ?? null,
+		});
+
+		if (options.loadDocs) {
+			c.doc = parseDoc(element);
+			c.metadata = parseMetadata(element);
+		}
+
+		return c;
+	}
+
+	asString<T extends FormatGenerator<unknown>>(generator: T): ReturnType<T["generateConst"]> {
+		return generator.generateConst(this) as ReturnType<T["generateConst"]>;
+	}
+}

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,129 @@
+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>();
+	isRegistered: boolean = false;
+	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, isRegistered, flags } = this;
+
+		const en = new IntrospectedEnum(name, namespace);
+
+		for (const [key, member] of (members ?? this.members).entries()) {
+			en.members.set(key, member.copy());
+		}
+
+		en.isRegistered = isRegistered;
+		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.isRegistered = true;
+			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;
+	}
+}