@ts-for-gir/lib 4.0.0-beta.9 → 4.0.0-rc.10

package/src/gir/registry.ts

@@ -0,0 +1,187 @@
+import { DefaultFormatter } from "../formatters/default.ts";
+import type { Formatter } from "../formatters/formatter.ts";
+import { JSONFormatter } from "../formatters/json.ts";
+import type { FormatGenerator } from "../generators/generator.ts";
+import { generify } from "../generics/generify.ts";
+import type { GirModule } from "../index.ts";
+import { inject } from "../injections/inject.ts";
+import type { GeneratorConstructor, OptionsGeneration, OptionsTransform } from "../types/index.ts";
+import { TwoKeyMap } from "../util.ts";
+import { ClassVisitor } from "../validators/class.ts";
+import { InterfaceVisitor } from "../validators/interface.ts";
+import type { GirVisitor } from "../visitor.ts";
+import type { IntrospectedNamespace } from "./namespace.ts";
+
+export class NSRegistry {
+	mapping: TwoKeyMap<string, string, IntrospectedNamespace> = new TwoKeyMap();
+	private formatters: Map<string, Formatter> = new Map();
+	private generators: Map<string, GeneratorConstructor<unknown>> = new Map();
+	c_mapping: Map<string, { version: string; name: string }[]> = new Map();
+	transformations: GirVisitor[] = [];
+	subtypes = new TwoKeyMap<string, string, TwoKeyMap<string, string, boolean>>();
+
+	constructor() {
+		this.formatters.set("json", new JSONFormatter());
+	}
+
+	registerTransformation(visitor: GirVisitor) {
+		this.transformations.push(visitor);
+
+		// Apply transformations to already built namespaces.
+		this.mapping.forEach((n) => {
+			n.accept(visitor);
+		});
+	}
+
+	registerFormatter(output: string, formatter: Formatter) {
+		this.formatters.set(output, formatter);
+	}
+
+	getFormatter(output: string) {
+		return this.formatters.get(output) ?? new DefaultFormatter();
+	}
+
+	registerGenerator<T>(
+		output: string,
+		generator: { new (namespace: IntrospectedNamespace, options: OptionsGeneration): FormatGenerator<T> },
+	) {
+		this.generators.set(output, generator);
+	}
+
+	async getGenerator<T>(output: string): Promise<GeneratorConstructor<T> | undefined> {
+		// Handle loading external generators...
+		if (!this.generators.has(output)) {
+			let Generator: { default: GeneratorConstructor<unknown> };
+			try {
+				Generator = (await import(`@gi.ts/generator-${output}`)) as { default: GeneratorConstructor<unknown> };
+
+				if (Generator) {
+					console.log(`Loading generator "@gi.ts/generator-${output}"...`);
+					this.generators.set(output, Generator.default);
+					return Generator.default as GeneratorConstructor<T>;
+				}
+			} catch {
+				try {
+					Generator = (await import(`gi-ts-generator-${output}`)) as {
+						default: GeneratorConstructor<unknown>;
+					};
+
+					console.log(`Loading generator "gi-ts-generator-${output}"...`);
+					this.generators.set(output, Generator.default);
+					return Generator.default as GeneratorConstructor<T>;
+				} catch {
+					try {
+						Generator = (await import(`${output}`)) as { default: GeneratorConstructor<unknown> };
+
+						console.log(`Loading generator "${output}"...`);
+						this.generators.set(output, Generator.default);
+						return Generator.default as GeneratorConstructor<T>;
+					} catch {}
+				}
+			}
+		}
+
+		return this.generators.get(output) as GeneratorConstructor<T> | undefined;
+	}
+
+	private _transformNamespace(namespace: IntrospectedNamespace) {
+		this.transformations.forEach((t) => {
+			namespace.accept(t);
+		});
+	}
+
+	namespace(name: string, version: string): IntrospectedNamespace | null {
+		const namespace = this.mapping.get(name, version);
+
+		return namespace ?? null;
+	}
+
+	namespacesForPrefix(c_prefix: string): IntrospectedNamespace[] {
+		return (this.c_mapping.get(c_prefix) ?? []).map((c_mapping) =>
+			this.assertNamespace(c_mapping.name, c_mapping.version),
+		);
+	}
+
+	transform(options: OptionsTransform) {
+		// In tolerant external-deps mode (with --allow-missing-deps) the core namespaces
+		// may not be loaded. Sync their package_version only when actually present;
+		// generify/inject still run on whatever IS loaded (other modules' transformations
+		// don't depend on GLib being in the registry).
+		const GLib = this.namespace("GLib", "2.0");
+		const Gio = this.namespace("Gio", "2.0");
+		const GObject = this.namespace("GObject", "2.0");
+
+		// These follow the GLib version.
+		if (GLib && Gio) Gio.package_version = [...GLib.package_version];
+		if (GLib && GObject) GObject.package_version = [...GLib.package_version];
+
+		const interfaceVisitor = new InterfaceVisitor();
+
+		this.registerTransformation(interfaceVisitor);
+
+		const classVisitor = new ClassVisitor();
+
+		this.registerTransformation(classVisitor);
+
+		if (GLib && Gio) {
+			console.log("Adding generics...");
+			generify(this, options.inferGenerics);
+
+			console.log("Injecting types...");
+			inject(this);
+		}
+	}
+
+	defaultVersionOf(name: string): string | null {
+		// GJS has a hard dependency on these versions.
+		if (name === "GLib" || name === "Gio" || name === "GObject") {
+			return "2.0";
+		}
+
+		const meta = this.mapping.getIfOnly(name);
+
+		if (meta) {
+			return meta[0];
+		}
+
+		return null;
+	}
+
+	assertDefaultVersionOf(name: string): string {
+		const version = this.defaultVersionOf(name);
+
+		if (version) {
+			return version;
+		}
+
+		// This mirrors GJS' and GI's default behavior.
+		// If we can't find a single version of an unspecified dependency, we throw an error.
+		throw new Error(`No single version found for unspecified dependency: ${JSON.stringify(name)}.`);
+	}
+
+	assertNamespace(name: string, version: string): IntrospectedNamespace {
+		const namespace = this.mapping.get(name, version) ?? null;
+
+		if (!namespace) {
+			throw new Error(`Namespace '${name}' not found.`);
+		}
+
+		return namespace;
+	}
+
+	register(namespace: GirModule): IntrospectedNamespace {
+		this.mapping.set(namespace.namespace, namespace.version, namespace);
+
+		namespace.c_prefixes.forEach((c_prefix) => {
+			const c_map = this.c_mapping.get(c_prefix) || [];
+
+			c_map.push({ name: namespace.namespace, version: namespace.version });
+
+			this.c_mapping.set(c_prefix, c_map);
+		});
+
+		this._transformNamespace(namespace);
+
+		return namespace;
+	}
+}

package/src/gir/signal.ts

@@ -0,0 +1,279 @@
+import type { GirCallableParamElement, GirSignalElement } from "@gi.ts/parser";
+import { GirDirection } from "@gi.ts/parser";
+import type { FormatGenerator } from "../generators/generator.ts";
+import {
+	ArrayType,
+	makeNullable,
+	NativeType,
+	NullableType,
+	NumberType,
+	ThisType,
+	type TypeExpression,
+	UnknownType,
+	VoidType,
+} from "../gir.ts";
+import type { OptionsLoad } from "../types/index.ts";
+import type { Options } from "../types/introspected.ts";
+import { getType, parseDoc, parseMetadata } from "../utils/gir-parsing.ts";
+import { isIntrospectable } from "../utils/girs.ts";
+import type { GirVisitor } from "../visitor.ts";
+import { IntrospectedClassMember } from "./introspected-class-member.ts";
+import {
+	type IntrospectedClass,
+	IntrospectedClassCallback,
+	IntrospectedClassFunction,
+} from "./introspected-classes.ts";
+import { IntrospectedFunctionParameter } from "./parameter.ts";
+
+export enum IntrospectedSignalType {
+	CONNECT,
+	CONNECT_AFTER,
+	EMIT,
+}
+
+export class IntrospectedSignal extends IntrospectedClassMember<IntrospectedClass> {
+	parameters: IntrospectedFunctionParameter[];
+	return_type: TypeExpression;
+	detailed: boolean;
+	action: boolean;
+	noRecurse: boolean;
+	noHooks: boolean;
+	when?: "first" | "last" | "cleanup";
+
+	constructor({
+		name,
+		parameters = [],
+		return_type = UnknownType,
+		detailed = false,
+		action = false,
+		noRecurse = false,
+		noHooks = false,
+		when,
+		parent,
+		...args
+	}: Options<{
+		name: string;
+		parameters?: IntrospectedFunctionParameter[];
+		return_type?: TypeExpression;
+		detailed?: boolean;
+		action?: boolean;
+		noRecurse?: boolean;
+		noHooks?: boolean;
+		when?: "first" | "last" | "cleanup";
+		parent: IntrospectedClass;
+	}>) {
+		super(name, parent, { ...args });
+
+		this.parameters = parameters.map((p) => p.copy({ parent: this }));
+		this.return_type = return_type;
+		this.detailed = detailed;
+		this.action = action;
+		this.noRecurse = noRecurse;
+		this.noHooks = noHooks;
+		this.when = when;
+	}
+
+	accept(visitor: GirVisitor): IntrospectedSignal {
+		const node = this.copy({
+			parameters: this.parameters.map((p) => {
+				return p.accept(visitor);
+			}),
+			returnType: visitor.visitType?.(this.return_type),
+		});
+
+		return visitor.visitSignal?.(node) ?? node;
+	}
+
+	copy({
+		parent = this.parent,
+		parameters,
+		returnType,
+		detailed,
+		action,
+		noRecurse,
+		noHooks,
+		when,
+	}: {
+		parent?: IntrospectedClass;
+		parameters?: IntrospectedFunctionParameter[];
+		returnType?: TypeExpression;
+		detailed?: boolean;
+		action?: boolean;
+		noRecurse?: boolean;
+		noHooks?: boolean;
+		when?: "first" | "last" | "cleanup";
+	} = {}): IntrospectedSignal {
+		return new IntrospectedSignal({
+			name: this.name,
+			parent,
+			parameters: parameters ?? this.parameters,
+			return_type: returnType ?? this.return_type,
+			detailed: detailed ?? this.detailed,
+			action: action ?? this.action,
+			noRecurse: noRecurse ?? this.noRecurse,
+			noHooks: noHooks ?? this.noHooks,
+			when: when ?? this.when,
+		})._copyBaseProperties(this);
+	}
+
+	static fromXML(element: GirSignalElement, parent: IntrospectedClass, options: OptionsLoad): IntrospectedSignal {
+		const ns = parent.namespace;
+		const signal = new IntrospectedSignal({
+			name: element.$.name,
+			parent,
+			detailed: element.$.detailed === "1",
+			action: element.$.action === "1",
+			noRecurse: element.$["no-recurse"] === "1",
+			noHooks: element.$["no-hooks"] === "1",
+			when: element.$.when as "first" | "last" | "cleanup" | undefined,
+			isIntrospectable: isIntrospectable(element),
+		});
+
+		if (element.parameters?.[0].parameter) {
+			signal.parameters.push(
+				...element.parameters[0].parameter
+					.filter((p): p is GirCallableParamElement & { $: { name: string } } => !!p.$.name)
+					.map((p) => IntrospectedFunctionParameter.fromXML(p, signal, options)),
+			);
+		}
+
+		const length_params = [] as number[];
+
+		signal.parameters = signal.parameters
+			.map((p) => {
+				const unwrapped_type = p.type.unwrap();
+
+				if (unwrapped_type instanceof ArrayType && unwrapped_type.length != null) {
+					length_params.push(unwrapped_type.length);
+
+					return p;
+				}
+
+				return p;
+			})
+			.filter((_, i) => {
+				// We remove any length parameters.
+				return !length_params.includes(i);
+			})
+
+			.reverse()
+			.reduce(
+				({ allowOptions, params }, p) => {
+					const { type, isOptional } = p;
+
+					if (allowOptions) {
+						if (type instanceof NullableType) {
+							params.push(p.copy({ isOptional: true }));
+						} else if (!isOptional) {
+							params.push(p);
+							return { allowOptions: false, params };
+						} else {
+							params.push(p);
+						}
+					} else {
+						if (isOptional) {
+							params.push(p.copy({ type: makeNullable(type), isOptional: false }));
+						} else {
+							params.push(p);
+						}
+					}
+
+					return { allowOptions, params };
+				},
+				{
+					allowOptions: true,
+					params: [] as IntrospectedFunctionParameter[],
+				},
+			)
+			.params.reverse()
+			.filter((p): p is IntrospectedFunctionParameter => p != null);
+
+		signal.return_type = getType(ns, element["return-value"]?.[0]);
+
+		if (options.loadDocs) {
+			signal.doc = parseDoc(element);
+			signal.metadata = parseMetadata(element);
+		}
+
+		return signal;
+	}
+
+	asEmit() {
+		const emit = this.copy();
+
+		const parent = this.parent;
+
+		const prefix_signal = emit.parameters.some((p) => {
+			return p.name === "signal";
+		});
+
+		const parameters = [
+			new IntrospectedFunctionParameter({
+				name: prefix_signal ? "$signal" : "signal",
+				type: NativeType.of(`'${this.name}'`),
+				direction: GirDirection.In,
+			}),
+			...emit.parameters,
+		];
+
+		const return_type = VoidType;
+
+		return new IntrospectedClassFunction({
+			return_type,
+			parameters,
+			name: "emit",
+			parent,
+		});
+	}
+
+	asConnect(after = false) {
+		const connect = this.copy();
+
+		const name = after ? "connect_after" : "connect";
+
+		const parent = this.parent;
+		const cb = new IntrospectedClassCallback({
+			parent,
+			name: "callback",
+			output_parameters: [],
+			parameters: [
+				new IntrospectedFunctionParameter({
+					name: "_source",
+					type: ThisType,
+					direction: GirDirection.In,
+				}),
+				...connect.parameters.map((p) => p.copy()),
+			],
+			return_type: connect.return_type,
+		});
+
+		const parameters = [
+			new IntrospectedFunctionParameter({
+				name: "signal",
+				type: NativeType.of(`'${this.name}'`),
+				direction: GirDirection.In,
+			}),
+			new IntrospectedFunctionParameter({
+				name: "callback",
+				type: cb.asFunctionType(),
+				direction: GirDirection.In,
+			}),
+		];
+
+		const return_type = NumberType;
+
+		return new IntrospectedClassFunction({
+			return_type,
+			parameters,
+			name,
+			parent: this.parent,
+		});
+	}
+
+	asString<T extends FormatGenerator<unknown>>(
+		generator: T,
+		type?: IntrospectedSignalType,
+	): ReturnType<T["generateSignal"]> {
+		return generator.generateSignal(this, type) as ReturnType<T["generateSignal"]>;
+	}
+}