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

package/src/injections/gtk4.ts

@@ -0,0 +1,23 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { JSField } from "../gir/property.ts";
+import { FunctionType, GenericType, GenerifiedType, NativeType } from "../gir.ts";
+
+export default {
+	namespace: "Gtk",
+	version: "4.0",
+	modifier(namespace: IntrospectedNamespace) {
+		{
+			const Widget = namespace.assertClass("Widget");
+
+			Widget.fields.push(
+				new JSField({
+					name: "Symbol.iterator",
+					parent: Widget,
+					computed: true,
+					doc: "Gtk.Widget is an iterable of its children.",
+					type: new FunctionType({}, new GenerifiedType(new NativeType("IterableIterator"), new GenericType("Widget"))),
+				}),
+			);
+		}
+	},
+};

package/src/injections/inject.ts

@@ -0,0 +1,49 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import type { NSRegistry } from "../gir/registry.ts";
+import gee1 from "./gee1.ts";
+import gee08 from "./gee08.ts";
+import gio from "./gio.ts";
+import glib from "./glib.ts";
+import gobject from "./gobject.ts";
+import gtk4 from "./gtk4.ts";
+import { shell14, shell15, shell16, shell17, shell18, shell19, shell20 } from "./shell.ts";
+import tracker1 from "./tracker1.ts";
+
+export type NamespaceInjection = (namespace: IntrospectedNamespace, registry: NSRegistry) => void;
+
+function injectDefinitions(registry: NSRegistry, required = true) {
+	return (definition: { namespace: string; version: string; modifier: NamespaceInjection }) => {
+		const ns = registry.namespace(definition.namespace, definition.version);
+
+		if (required && !ns) {
+			throw new Error(`Namespace '${definition.namespace}' not found.`);
+		}
+
+		if (ns) {
+			definition.modifier(ns, registry);
+		}
+	};
+}
+
+export function inject(registry: NSRegistry) {
+	const $ = injectDefinitions(registry);
+
+	$(glib);
+	$(gobject);
+	$(gio);
+
+	const $_ = injectDefinitions(registry, false);
+
+	// Optional injections
+	$_(tracker1);
+	$_(gee08);
+	$_(gee1);
+	$_(gtk4);
+	$_(shell14);
+	$_(shell15);
+	$_(shell16);
+	$_(shell17);
+	$_(shell18);
+	$_(shell19);
+	$_(shell20);
+}

package/src/injections/shell.ts

@@ -0,0 +1,49 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import type { NSRegistry } from "../gir/registry.ts";
+import { NullableType, OrType, TypeIdentifier } from "../gir.ts";
+
+const shellTemplate = (version: string) => ({
+	namespace: "Shell",
+	version,
+	modifier(namespace: IntrospectedNamespace, _registry: NSRegistry) {
+		// Get the GLSLEffect class which contains the add_glsl_snippet method
+		const GLSLEffect = namespace.assertClass("GLSLEffect");
+
+		// Find the add_glsl_snippet method
+		const addGlslSnippet = GLSLEffect.members.find((m) => m.name === "add_glsl_snippet");
+
+		// Change
+		// ```ts
+		// add_glsl_snippet(hook: SnippetHook | null, declarations: string, code: string, is_replace: boolean): void;
+		// ```
+		// to
+		// ```ts
+		// add_glsl_snippet(hook: SnippetHook | Cogl.SnippetHook | null, declarations: string, code: string, is_replace: boolean): void;
+		// ```
+
+		if (addGlslSnippet) {
+			// Create a new parameter with updated type using copy()
+			const updatedParameter = addGlslSnippet.parameters[0].copy({
+				type: new NullableType(
+					new OrType(new TypeIdentifier("SnippetHook", "Shell"), new TypeIdentifier("SnippetHook", "Cogl")),
+				),
+			});
+
+			// Replace the original parameter
+			addGlslSnippet.parameters[0] = updatedParameter;
+		}
+	},
+});
+
+/** Shell 14 was introduced with GNOME 45 */
+export const shell14 = shellTemplate("14");
+/** Shell 15 was introduced with GNOME 47 */
+export const shell15 = shellTemplate("15");
+/** Shell 16 was introduced with GNOME 48 */
+export const shell16 = shellTemplate("16");
+/** Shell 17 was introduced with GNOME 49 */
+export const shell17 = shellTemplate("17");
+// Possibly future versions, adjust if necessary
+export const shell18 = shellTemplate("18");
+export const shell19 = shellTemplate("19");
+export const shell20 = shellTemplate("20");

package/src/injections/tracker1.ts

@@ -0,0 +1,42 @@
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+import { IntrospectedRecord } from "../gir/record.ts";
+import { ClassStructTypeIdentifier } from "../gir.ts";
+
+export default {
+	namespace: "Tracker",
+	version: "1.0",
+	modifier(namespace: IntrospectedNamespace) {
+		const SparqlError = namespace.getEnum("Error");
+
+		if (!SparqlError) throw new Error("Error enum not found in Tracker.");
+
+		namespace.members.delete("Error");
+
+		SparqlError.name = "SparqlError";
+
+		namespace.members.set("SparqlError", SparqlError);
+
+		// Hack around broken references in Tracker
+
+		const CursorClass = namespace.members.get("SparqlCursorClass");
+
+		if (CursorClass instanceof IntrospectedRecord) {
+			// @ts-expect-error This is a private property by Tracker is cursed
+			CursorClass._structFor = new ClassStructTypeIdentifier("SparqlCursor", "Tracker");
+		}
+
+		const ConnectionClass = namespace.members.get("SparqlConnectionClass");
+
+		if (ConnectionClass instanceof IntrospectedRecord) {
+			// @ts-expect-error This is a private property by Tracker is cursed
+			ConnectionClass._structFor = new ClassStructTypeIdentifier("SparqlConnection", "Tracker");
+		}
+
+		const BuilderClass = namespace.members.get("SparqlBuilderClass");
+
+		if (BuilderClass instanceof IntrospectedRecord) {
+			// @ts-expect-error This is a private property by Tracker is cursed
+			BuilderClass._structFor = new ClassStructTypeIdentifier("SparqlBuilder", "Tracker");
+		}
+	},
+};

package/src/library-version.ts

@@ -0,0 +1,50 @@
+import type { GirConstantElement } from "./types/index.ts";
+
+export class LibraryVersion {
+	major: number | undefined;
+	minor: number | undefined;
+	patch: number | undefined;
+
+	constructor(constants: GirConstantElement[] = [], version = "0.0.0") {
+		const [_major, _minor, _micro] = version.split(".").filter((v) => v !== "");
+		if (_major) {
+			this.major = Number(_major) || undefined;
+		}
+		if (_minor) {
+			this.minor = Number(_minor) || undefined;
+		}
+		if (_micro) {
+			this.patch = Number(_micro) || undefined;
+		}
+
+		for (const constant of constants) {
+			if (constant.$.name === "MAJOR_VERSION" || (constant.$.name === "VERSION_MAJOR" && constant.$.value)) {
+				this.major = Number(constant.$.value) || undefined;
+			}
+			if (constant.$.name === "MINOR_VERSION" || (constant.$.name === "VERSION_MINOR" && constant.$.value)) {
+				this.minor = Number(constant.$.value) || undefined;
+			}
+			if (constant.$.name === "MICRO_VERSION" || (constant.$.name === "VERSION_MICRO" && constant.$.value)) {
+				this.patch = Number(constant.$.value) || undefined;
+			}
+		}
+	}
+
+	toString() {
+		return `${this.major || "0"}.${this.minor || "0"}.${this.patch || "0"}`;
+	}
+
+	/** Compare two library versions and return -1 if this version is greater than the other, 1 if this version is less than the other, and 0 if they are equal. */
+	compare(other: LibraryVersion) {
+		if (this.major !== other.major) {
+			return (this.major || 0) > (other.major || 0) ? -1 : 1;
+		}
+		if (this.minor !== other.minor) {
+			return (this.minor || 0) > (other.minor || 0) ? -1 : 1;
+		}
+		if (this.patch !== other.patch) {
+			return (this.patch || 0) > (other.patch || 0) ? -1 : 1;
+		}
+		return 0;
+	}
+}

package/src/logger.ts

@@ -0,0 +1,104 @@
+/**
+ * A logger that displays information in different colors on the console.
+ * In addition, the environment or the module currently being processed is also included as prepended to the logging string
+ */
+
+import { blue, gray, green, red, yellow, yellowBright } from "colorette";
+
+export class Logger {
+	private readonly verbose: boolean;
+	private readonly moduleName: string;
+	constructor(verbose: boolean, moduleName: string) {
+		this.verbose = verbose;
+		this.moduleName = moduleName;
+	}
+	private static prepend(txt: string, prepend: string): string {
+		if (typeof txt === "string") {
+			txt = `${prepend}${txt}`;
+		}
+		return txt;
+	}
+	/**
+	 * Returns something like '[node][Gda-5.0] Could not find type 'Gda.SqlExpr' for 'expr''
+	 * @param txt
+	 * @param logLevel
+	 */
+	private prependInfo(txt: string, logLevel?: "WARN:" | "ERROR:" | "INFO:" | "DEBUG:"): string {
+		if (logLevel || this.moduleName.length > 0) {
+			txt = Logger.prepend(txt, " ");
+		}
+		if (logLevel) {
+			if (this.moduleName.length > 0) {
+				txt = Logger.prepend(txt, ` ${logLevel}`);
+			} else {
+				txt = Logger.prepend(txt, logLevel);
+			}
+		}
+		if (this.moduleName.length > 0) {
+			txt = Logger.prepend(txt, `[${this.moduleName}]`);
+		}
+
+		return txt;
+	}
+
+	public log(...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		console.log(...args);
+	}
+	public dir(...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		args.forEach((arg) => {
+			console.dir(arg);
+		});
+		return;
+	}
+	public info(txt: string, ...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		console.info(blue(txt), ...args);
+	}
+	public warn(txt: string, ...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		txt = this.prependInfo(txt, "WARN:");
+		console.warn(yellow(txt), ...args);
+	}
+	public debug(txt: string, ...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		txt = this.prependInfo(txt, "DEBUG:");
+		console.debug(yellowBright(txt), ...args);
+	}
+	public error(txt: string, ...args: unknown[]): void {
+		txt = this.prependInfo(txt, "ERROR:");
+		this.danger(txt, ...args);
+	}
+	public success(txt: string, ...args: unknown[]): void {
+		if (!this.verbose) {
+			return;
+		}
+		this.log(green(txt), ...args);
+	}
+	public danger(txt: string, ...args: unknown[]): void {
+		console.error(red(txt), ...args);
+	}
+	public muted(txt: string, ...args: unknown[]): void {
+		this.log(gray(txt), ...args);
+	}
+	public white(txt: string, ...args: unknown[]): void {
+		this.log(txt, ...args);
+	}
+	public yellow(txt: string, ...args: unknown[]): void {
+		this.log(yellow(txt), ...args);
+	}
+	public gray(txt: string, ...args: unknown[]): void {
+		this.log(gray(txt), ...args);
+	}
+}

package/src/messages.ts

@@ -0,0 +1,57 @@
+export const NO_TSDATA = (namespace?: string) => {
+	let message = "You need to set the tsData first!";
+	if (namespace) message = `[${namespace}] ${message}`;
+	return message;
+};
+
+// Error messages
+
+export const ERROR_NO_MODULES_FOUND = (girDirectories: string[]) => `No module found in ${girDirectories.join(", ")}!
+Please make sure that you have installed the necessary gir files.
+For example with "sudo apt install libgtk-4-dev" for Gtk4 on Ubuntu or "sudo dnf install gtk4-devel" on Fedora.`;
+export const ERROR_CONFIG_EXTENSION_UNSUPPORTED =
+	"Only configs with the extension .js and .json are currently supported. Do nothing";
+export const ERROR_NO_MODULE_SPECIFIED = "Need to specify modules!";
+
+// Warn messages
+
+export const WARN_NO_GIR_FILE_FOUND_FOR_PACKAGE = (packageName: string) =>
+	`No gir file found for '${packageName}', this module will be ignored`;
+export const WARN_CONSTANT_ALREADY_EXPORTED = (name: string) => `The constant '${name}' has already been exported`;
+
+export const WARN_DUPLICATE_ENUM_IDENTIFIER = (name: string, renamed: string) =>
+	`Enum has a duplicate identifier '${name}', renamed to '${renamed}'!`;
+export const WARN_DUPLICATE_SYMBOL = (symbol: string) => `Duplicate symbol: ${symbol}`;
+export const WARN_DUPLICATE_PARAMETER = (paramName: string, namespace?: string) => {
+	let message = `Duplicate parameter name "${paramName}" found!`;
+	if (namespace) message = `[${namespace}] ${message}`;
+	return message;
+};
+
+export const WARN_NOT_FOUND_TYPE = (logName: string) => `Could not find type for "${logName}"`;
+export const WARN_NOT_FOUND_PACKAGE_NAME = (namespace: string, implementation: string) =>
+	`Package name for namespace ${namespace} not found! (${implementation})`;
+
+export const WARN_RENAMED_PROPERTY = (originalName: string, newName: string) =>
+	`Property name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_FUNCTION = (originalName: string, newName: string) =>
+	`Function name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_CLASS = (originalName: string, newName: string) =>
+	`Class name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_CONSTANT = (originalName: string, newName: string) =>
+	`Constant name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_FIELD = (originalName: string, newName: string) =>
+	`Field name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_ENUM = (originalName: string, newName: string) =>
+	`Enum name renamed from '${originalName}' to '${newName}'`;
+export const WARN_RENAMED_PARAMETER = (originalName: string, newName: string) =>
+	`Parameter name renamed from '${originalName}' to '${newName}'`;
+
+// Info messages
+
+export const DANGER_HTML_DOC_GENERATOR_NOT_IMPLEMENTED =
+	"The HtmlDocGenerator is currently not implemented. Do nothing...";
+export const START_MODULE = "Start to generate .d.ts files...";
+export const FILE_PARSING_DONE = "Files parsed, loading types...";
+export const TSDATA_PARSING_DONE = "Typescript data loaded, generating .d.ts...";
+export const GENERATING_TYPES_DONE = "Done.";

package/src/templates/index.ts

@@ -0,0 +1 @@
+export * from "./template-engine.ts"; 

package/src/templates/template-engine.ts

@@ -0,0 +1,178 @@
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, extname, join, resolve } from "node:path";
+import ejs from "ejs";
+
+import { fileExists, Logger } from "../index.ts";
+import type { TemplateData } from "../types/index.ts";
+
+const require = createRequire(import.meta.url);
+
+/**
+ * Core template engine for rendering EJS templates
+ * This is a generic utility that can be used by different generators
+ */
+export class TemplateEngine {
+	protected log: Logger;
+	protected readonly templateDir: string;
+
+	constructor(templateDir?: string) {
+		this.templateDir = templateDir ?? this.resolveTemplateDirectory();
+		this.log = new Logger(false, "TemplateEngine");
+	}
+
+	/**
+	 * Resolves the templates directory from the @ts-for-gir/templates package
+	 * Try require.resolve first, fallback to workspace path for development
+	 */
+	private resolveTemplateDirectory(): string {
+		try {
+			return join(dirname(require.resolve("@ts-for-gir/templates/package.json")), "templates");
+		} catch (_error) {
+			// Fallback for workspace development setup
+			return resolve(process.cwd(), "../../templates/templates");
+		}
+	}
+
+	/**
+	 * Gets the append template name for a given template filename
+	 */
+	protected getAppendTemplateName(templateFilename: string): string {
+		let appendTemplateFilename = templateFilename;
+
+		if (appendTemplateFilename.endsWith(".d.ts")) {
+			appendTemplateFilename = appendTemplateFilename.replace(".d.ts", ".append.d.ts");
+		} else if (extname(appendTemplateFilename)) {
+			const ext = extname(appendTemplateFilename);
+			appendTemplateFilename = appendTemplateFilename.replace(ext, `.append${ext}`);
+		} else {
+			appendTemplateFilename += ".append";
+		}
+		return appendTemplateFilename;
+	}
+
+	/**
+	 * Checks if the template file or directory exists and returns the path if found
+	 */
+	public async exists(templateFilename: string): Promise<string | null> {
+		const fullTemplatePath = join(this.templateDir, templateFilename);
+		if (await fileExists(fullTemplatePath)) {
+			return fullTemplatePath;
+		}
+		return null;
+	}
+
+	/**
+	 * Removes TypeScript directive comments from the first line of a template
+	 */
+	protected removeTypeScriptDirectives(content: string): string {
+		const lines = content.split("\n");
+		if (lines.length > 0 && (lines[0].includes("// @ts-nocheck") || lines[0].includes("// @ts-ignore"))) {
+			lines.shift(); // Remove the first line
+			return lines.join("\n");
+		}
+		return content;
+	}
+
+	/**
+	 * Reads a template file from filesystem and gets the raw string back
+	 */
+	protected async read(templateFilename: string): Promise<string> {
+		const path = await this.exists(templateFilename);
+		if (path) {
+			const content = await readFile(path, "utf8");
+			return this.removeTypeScriptDirectives(content);
+		}
+		throw new Error(`Template '${path || templateFilename}' not found'`);
+	}
+
+	/**
+	 * Reads all template files from a directory and gets the raw strings back
+	 */
+	protected async readAll(templateDirname: string, fileExtension: string): Promise<{ [path: string]: string }> {
+		const path = await this.exists(templateDirname);
+		if (path) {
+			const files = (await readdir(path)).filter((file) => file.endsWith(fileExtension));
+			if (files.length === 0) {
+				throw new Error(`Template directory '${templateDirname}' is empty'`);
+			}
+			const results: { [path: string]: string } = {};
+			for (const file of files) {
+				const content = await readFile(join(path, file), "utf8");
+				results[file] = this.removeTypeScriptDirectives(content);
+			}
+			return results;
+		}
+		throw new Error(`Template directory '${templateDirname}' not found'`);
+	}
+
+	/**
+	 * Renders a template string with the given data and options
+	 */
+	protected async render(
+		templateString: string,
+		data: TemplateData,
+		options: Partial<ejs.Options> = {},
+	): Promise<string> {
+		try {
+			const renderedTpl = await ejs.render(templateString, data, {
+				async: true,
+				...options,
+			});
+			return renderedTpl;
+		} catch (error) {
+			this.log.error(`Error on render "${templateString}":`, error);
+			throw error;
+		}
+	}
+
+	/**
+	 * Loads and renders a template and gets the rendered templates back
+	 */
+	public async load(
+		templateFilename: string,
+		data: TemplateData,
+		ejsOptions: Partial<ejs.Options> = {},
+	): Promise<{ prepend: string; append: string }> {
+		const fileContent = await this.read(templateFilename);
+		const prepend = await this.render(fileContent, data, ejsOptions);
+		let append = "";
+
+		const appendTemplateFilename = this.getAppendTemplateName(templateFilename);
+		if (await this.exists(appendTemplateFilename)) {
+			const appendFileContent = await this.read(appendTemplateFilename);
+			append = await this.render(appendFileContent, data, ejsOptions);
+		}
+
+		return { prepend, append };
+	}
+
+	/**
+	 * Loads and renders all templates in a directory and gets the rendered templates back
+	 */
+	public async loadAll(
+		templateDirname: string,
+		fileExtension: string,
+		data: TemplateData,
+		ejsOptions: Partial<ejs.Options> = {},
+	): Promise<{ [path: string]: string }> {
+		const fileContents = await this.readAll(templateDirname, fileExtension);
+		for (const file of Object.keys(fileContents)) {
+			fileContents[file] = await this.render(fileContents[file], data, ejsOptions);
+		}
+		return fileContents;
+	}
+
+	/**
+	 * Writes content to the filesystem
+	 */
+	public async writeFile(content: string, outputPath: string): Promise<string> {
+		this.log.info("Writing to", outputPath);
+
+		// write template result file
+		await mkdir(dirname(outputPath), { recursive: true });
+		await writeFile(outputPath, content, { encoding: "utf8", flag: "w" });
+
+		return Promise.resolve(outputPath);
+	}
+} 

package/src/types/answer-version.ts

@@ -0,0 +1,4 @@
+export interface AnswerVersion {
+	selected: string[];
+	unselected: string[];
+}

package/src/types/any-introspected-type.ts

@@ -0,0 +1,5 @@
+import type { IntrospectedBase } from "../gir/introspected-base.ts";
+import type { IntrospectedNamespace } from "../gir/namespace.ts";
+
+// Recursive type representing any IntrospectedBase with a valid parent constraint
+export type AnyIntrospectedType = IntrospectedBase<IntrospectedNamespace | AnyIntrospectedType | null>;

package/src/types/class-function-types.ts

@@ -0,0 +1,57 @@
+import type { IntrospectedEnum } from "../gir/enum.ts";
+import type { IntrospectedBaseClass, IntrospectedClassFunction } from "../gir/introspected-classes.ts";
+import type { IntrospectedFunctionParameter } from "../gir/parameter.ts";
+import type { Generic, TypeExpression } from "../gir.ts";
+import type { GirVisitor } from "../visitor.ts";
+
+export interface ClassFunctionCopyOptions<Parent> {
+	parent?: Parent;
+	name?: string;
+	interfaceParent?: IntrospectedBaseClass | IntrospectedEnum; // avoid circular deps by importing types only
+	parameters?: IntrospectedFunctionParameter[];
+	outputParameters?: IntrospectedFunctionParameter[];
+	returnType?: TypeExpression;
+}
+
+export interface ClassFunctionOptions<Parent> {
+	name: string;
+	parameters?: IntrospectedFunctionParameter[];
+	output_parameters?: IntrospectedFunctionParameter[];
+	return_type?: TypeExpression;
+	parent: Parent;
+	originalParent?: Parent | null;
+	doc?: string | null;
+}
+
+// Type discriminators for function types
+export const FunctionTypeKind = {
+	CLASS_FUNCTION: "CLASS_FUNCTION",
+	VIRTUAL_CLASS_FUNCTION: "VIRTUAL_CLASS_FUNCTION",
+	STATIC_CLASS_FUNCTION: "STATIC_CLASS_FUNCTION",
+	CONSTRUCTOR: "CONSTRUCTOR",
+} as const;
+
+export type FunctionTypeKind = (typeof FunctionTypeKind)[keyof typeof FunctionTypeKind];
+
+// Base interface for all class functions to enable type checking
+export interface ClassFunctionLike {
+	readonly __functionTypeKind: FunctionTypeKind;
+	readonly parameters: IntrospectedFunctionParameter[];
+	readonly output_parameters: IntrospectedFunctionParameter[];
+	readonly generics: Generic[];
+	returnTypeDoc?: string | null;
+	interfaceParent?: IntrospectedBaseClass | IntrospectedEnum | null;
+
+	anyify(): IntrospectedClassFunction;
+	shouldAnyify(): boolean;
+	return(): TypeExpression;
+	getCallbackParameters(): {
+		name: string;
+		parent: IntrospectedBaseClass | IntrospectedEnum;
+		output_parameters: IntrospectedFunctionParameter[];
+		parameters: IntrospectedFunctionParameter[];
+		return_type: TypeExpression;
+	};
+	copy(options?: ClassFunctionCopyOptions<IntrospectedBaseClass | IntrospectedEnum>): IntrospectedClassFunction;
+	accept(visitor: GirVisitor): IntrospectedClassFunction;
+}

package/src/types/class-member.ts

@@ -0,0 +1,5 @@
+import type { IntrospectedClassMember } from "../gir/introspected-class-member.ts";
+import type { IntrospectedClassFunction } from "../gir/introspected-classes.ts";
+import type { IntrospectedProperty } from "../gir/property.ts";
+
+export type ClassMember = IntrospectedClassMember | IntrospectedClassFunction | IntrospectedProperty;

package/src/types/class-parent.ts

@@ -0,0 +1,14 @@
+import type { GirClassElement, GirInterfaceElement, GirRecordElement, GirUnionElement, TypeGirClass } from "./index.ts";
+
+export interface ClassParent {
+	parentName: string;
+	qualifiedParentName: string;
+	/** qualified if its module != qualifiedName's module */
+	localParentName: string;
+	type: "parent" | "prerequisite" | "implements";
+	/** Parent class / interface */
+	cls?: GirClassElement | GirUnionElement | GirInterfaceElement | GirRecordElement;
+	girTypeName: TypeGirClass;
+	/** True if the parent dependency exists */
+	dependencyExists: boolean;
+}