@gtkx/gir 0.10.5 → 0.11.0

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Naming utilities for GIR identifiers.
+ */
+/** Converts kebab-case or snake_case to camelCase */
+export declare const toCamelCase: (str: string) => string;
+/** Converts kebab-case or snake_case to PascalCase */
+export declare const toPascalCase: (str: string) => string;

package/dist/utils.js

@@ -0,0 +1,10 @@
+/**
+ * Naming utilities for GIR identifiers.
+ */
+/** Converts kebab-case or snake_case to camelCase */
+export const toCamelCase = (str) => str.replace(/[-_]([a-z])/g, (_, letter) => letter.toUpperCase());
+/** Converts kebab-case or snake_case to PascalCase */
+export const toPascalCase = (str) => {
+    const camel = toCamelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gtkx/gir",
-  "version": "0.10.5",
+  "version": "0.11.0",
   "description": "GObject Introspection file parser for GTKX",
   "keywords": [
     "gtk",

package/dist/class-names.d.ts

@@ -1,2 +0,0 @@
-export declare const CLASS_RENAMES: Map<string, string>;
-export declare const normalizeClassName: (name: string, namespace?: string) => string;

package/dist/class-names.js

@@ -1,12 +0,0 @@
-import { toPascalCase } from "./naming.js";
-export const CLASS_RENAMES = new Map([["Error", "GError"]]);
-export const normalizeClassName = (name, namespace) => {
-    const pascalName = toPascalCase(name);
-    if (CLASS_RENAMES.has(pascalName)) {
-        return CLASS_RENAMES.get(pascalName);
-    }
-    if (pascalName === "Object" && namespace) {
-        return namespace === "GObject" ? "GObject" : `${namespace}Object`;
-    }
-    return pascalName;
-};

package/dist/doc-sanitizer.d.ts

@@ -1,13 +0,0 @@
-export interface SanitizeDocOptions {
-    escapeXmlTags?: boolean;
-    namespace?: string;
-    linkStyle?: "namespaced" | "prefixed";
-}
-export declare function sanitizeDoc(doc: string, options?: SanitizeDocOptions): string;
-export declare function formatDoc(doc: string | undefined, indent?: string, options?: SanitizeDocOptions): string;
-interface DocParameter {
-    name: string;
-    doc: string | undefined;
-}
-export declare function formatMethodDoc(doc: string | undefined, params: DocParameter[], indent?: string, options?: SanitizeDocOptions): string;
-export {};

package/dist/doc-sanitizer.js

@@ -1,334 +0,0 @@
-const GIR_LINK_PATTERN = /\[([a-z]+)@([^\]]+)\]/gi;
-function parseGirLink(type, reference) {
-    const linkType = type.toLowerCase();
-    const validTypes = [
-        "class",
-        "iface",
-        "struct",
-        "enum",
-        "flags",
-        "error",
-        "callback",
-        "method",
-        "vfunc",
-        "func",
-        "ctor",
-        "property",
-        "signal",
-        "const",
-        "type",
-        "id",
-    ];
-    if (!validTypes.includes(linkType)) {
-    }
-    const parts = reference.split(".");
-    if (parts.length === 0) {
-    }
-    if (linkType === "property" || linkType === "signal") {
-        const colonIndex = reference.indexOf(":");
-        if (colonIndex !== -1) {
-            const beforeColon = reference.substring(0, colonIndex);
-            const afterColon = reference.substring(colonIndex + 1);
-            const beforeParts = beforeColon.split(".");
-            if (beforeParts.length >= 2) {
-                return {
-                    type: linkType,
-                    namespace: beforeParts[0],
-                    target: beforeParts.slice(1).join("."),
-                    member: afterColon.replace("::", ""),
-                };
-            }
-            return {
-                type: linkType,
-                namespace: undefined,
-                target: beforeColon,
-                member: afterColon.replace("::", ""),
-            };
-        }
-    }
-    if (parts.length === 1) {
-        return {
-            type: linkType,
-            namespace: undefined,
-            target: parts[0] ?? "",
-            member: undefined,
-        };
-    }
-    if (parts.length === 2) {
-        const first = parts[0] ?? "";
-        const second = parts[1] ?? "";
-        const isNamespace = first.length > 0 && first[0] === first[0]?.toUpperCase();
-        if (linkType === "func" || linkType === "const") {
-            return {
-                type: linkType,
-                namespace: first,
-                target: second,
-                member: undefined,
-            };
-        }
-        if (isNamespace) {
-            return {
-                type: linkType,
-                namespace: first,
-                target: second,
-                member: undefined,
-            };
-        }
-        return {
-            type: linkType,
-            namespace: undefined,
-            target: first,
-            member: second,
-        };
-    }
-    return {
-        type: linkType,
-        namespace: parts[0],
-        target: parts[1] ?? "",
-        member: parts.slice(2).join(".") || undefined,
-    };
-}
-function formatGirLinkForTsDoc(link, options) {
-    let displayText;
-    if (link.member) {
-        displayText = `${link.target}.${link.member}`;
-    }
-    else {
-        displayText = link.target;
-    }
-    let linkTarget;
-    if (options.linkStyle === "prefixed") {
-        const effectiveNamespace = link.namespace ?? options.currentNamespace;
-        if (effectiveNamespace && effectiveNamespace !== "Gtk") {
-            linkTarget = `${effectiveNamespace}${displayText}`;
-        }
-        else {
-            linkTarget = displayText;
-        }
-    }
-    else {
-        linkTarget = link.namespace ? `${link.namespace}.${displayText}` : displayText;
-    }
-    switch (link.type) {
-        case "class":
-        case "iface":
-        case "struct":
-        case "enum":
-        case "flags":
-        case "error":
-        case "callback":
-        case "type":
-            return `{@link ${linkTarget}}`;
-        case "method":
-        case "vfunc":
-        case "func":
-        case "ctor":
-            return `{@link ${linkTarget}}`;
-        case "property":
-            return `{@link ${linkTarget}}`;
-        case "signal":
-            return `{@link ${linkTarget}}`;
-        case "const":
-            return `{@link ${linkTarget}}`;
-        case "id":
-            return `\`${link.target}\``;
-        default:
-            return `\`${displayText}\``;
-    }
-}
-function convertGirLinks(text, options) {
-    return text.replace(GIR_LINK_PATTERN, (_, type, reference) => {
-        const link = parseGirLink(type, reference);
-        if (!link) {
-            return `\`${reference}\``;
-        }
-        return formatGirLinkForTsDoc(link, options);
-    });
-}
-const GTK_DOCS_BASE_URLS = {
-    Gtk: "https://docs.gtk.org/gtk4",
-    Gdk: "https://docs.gtk.org/gdk4",
-    Gsk: "https://docs.gtk.org/gsk4",
-    GLib: "https://docs.gtk.org/glib",
-    GObject: "https://docs.gtk.org/gobject",
-    Gio: "https://docs.gtk.org/gio",
-    Pango: "https://docs.gtk.org/Pango",
-    PangoCairo: "https://docs.gtk.org/PangoCairo",
-    GdkPixbuf: "https://docs.gtk.org/gdk-pixbuf",
-    Cairo: "https://docs.gtk.org/cairo",
-    Adw: "https://gnome.pages.gitlab.gnome.org/libadwaita/doc/1-latest",
-};
-function getDocsBaseUrl(namespace) {
-    if (!namespace) {
-        return "https://docs.gtk.org/gtk4";
-    }
-    const baseUrl = GTK_DOCS_BASE_URLS[namespace];
-    if (baseUrl) {
-        return baseUrl;
-    }
-    return `https://docs.gtk.org/${namespace.toLowerCase()}`;
-}
-function convertHtmlImageElements(text, baseUrl) {
-    let result = text;
-    result = result.replace(/<picture[^>]*>([\s\S]*?)<\/picture>/gi, (_, pictureContent) => {
-        const imgMatch = /<img[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*\/?>/i.exec(pictureContent);
-        if (!imgMatch) {
-            const imgMatch2 = /<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/i.exec(pictureContent);
-            if (imgMatch2) {
-                const src = imgMatch2[1];
-                const alt = imgMatch2[2];
-                return `![${alt}](${baseUrl}/${src})`;
-            }
-            return "";
-        }
-        const alt = imgMatch[1];
-        const src = imgMatch[2];
-        return `![${alt}](${baseUrl}/${src})`;
-    });
-    result = result.replace(/<img[^>]*alt="([^"]*)"[^>]*src="([^"]*)"[^>]*\/?>/gi, (_, alt, src) => {
-        if (src.startsWith("http://") || src.startsWith("https://")) {
-            return `![${alt}](${src})`;
-        }
-        return `![${alt}](${baseUrl}/${src})`;
-    });
-    result = result.replace(/<img[^>]*src="([^"]*)"[^>]*alt="([^"]*)"[^>]*\/?>/gi, (_, src, alt) => {
-        if (src.startsWith("http://") || src.startsWith("https://")) {
-            return `![${alt}](${src})`;
-        }
-        return `![${alt}](${baseUrl}/${src})`;
-    });
-    result = result.replace(/<img[^>]*src="([^"]*)"[^>]*\/?>/gi, (_, src) => {
-        if (src.startsWith("http://") || src.startsWith("https://")) {
-            return `![](${src})`;
-        }
-        return `![](${baseUrl}/${src})`;
-    });
-    result = result.replace(/<source[^>]*\/?>/gi, "");
-    return result;
-}
-function convertMarkdownImageUrls(text, baseUrl) {
-    return text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (match, alt, src) => {
-        if (src.startsWith("http://") || src.startsWith("https://")) {
-            return match;
-        }
-        return `![${alt}](${baseUrl}/${src})`;
-    });
-}
-function convertKbdElements(text) {
-    return text.replace(/<kbd>([^<]*)<\/kbd>/gi, "`$1`");
-}
-function stripHtmlLinks(text) {
-    return text.replace(/\[([^\]]+)\]\([^)]+\.html[^)]*\)/gi, "$1");
-}
-function convertAtAnnotations(text) {
-    return text.replace(/(?<!\{)@([a-zA-Z_][a-zA-Z0-9_]*)\b(?!\s*\{)/g, "`$1`");
-}
-function escapeXmlStyleTags(text) {
-    const codeBlockPattern = /```[\s\S]*?```/g;
-    const codeBlocks = [];
-    let processed = text.replace(codeBlockPattern, (match) => {
-        codeBlocks.push(match);
-        return `__CODE_BLOCK_${codeBlocks.length - 1}__`;
-    });
-    processed = processed.replace(/<(\/?)(child|object|property|signal|template|style|item|attribute)>/gi, "`<$1$2>`");
-    for (let i = 0; i < codeBlocks.length; i++) {
-        processed = processed.replace(`__CODE_BLOCK_${i}__`, codeBlocks[i] ?? "");
-    }
-    return processed;
-}
-function cleanupWhitespace(text) {
-    let result = text.replace(/\n{3,}/g, "\n\n");
-    result = result.replace(/[ \t]+$/gm, "");
-    return result.trim();
-}
-function protectCodeBlocks(text) {
-    const codeBlockPattern = /```[\s\S]*?```/g;
-    const codeBlocks = [];
-    const processed = text.replace(codeBlockPattern, (match) => {
-        codeBlocks.push(match);
-        return `__PROTECTED_CODE_BLOCK_${codeBlocks.length - 1}__`;
-    });
-    const restore = (formatted, linePrefix) => {
-        let result = formatted;
-        for (let i = 0; i < codeBlocks.length; i++) {
-            const placeholder = `__PROTECTED_CODE_BLOCK_${i}__`;
-            const codeBlock = codeBlocks[i];
-            if (codeBlock === undefined)
-                continue;
-            const codeLines = codeBlock.split("\n");
-            const prefixedCodeLines = codeLines.map((line, index) => {
-                if (index === 0)
-                    return line;
-                return `${linePrefix}${line}`;
-            });
-            result = result.replace(placeholder, prefixedCodeLines.join("\n"));
-        }
-        return result;
-    };
-    return { text: processed, restore };
-}
-export function sanitizeDoc(doc, options = {}) {
-    let result = doc;
-    const baseUrl = getDocsBaseUrl(options.namespace);
-    result = convertHtmlImageElements(result, baseUrl);
-    result = convertMarkdownImageUrls(result, baseUrl);
-    result = convertKbdElements(result);
-    result = stripHtmlLinks(result);
-    const linkFormatOptions = {
-        linkStyle: options.linkStyle ?? "namespaced",
-        currentNamespace: options.namespace,
-    };
-    result = convertGirLinks(result, linkFormatOptions);
-    result = convertAtAnnotations(result);
-    if (options.escapeXmlTags) {
-        result = escapeXmlStyleTags(result);
-    }
-    result = cleanupWhitespace(result);
-    return result;
-}
-export function formatDoc(doc, indent = "", options = {}) {
-    if (!doc) {
-        return "";
-    }
-    const sanitized = sanitizeDoc(doc, options);
-    if (!sanitized) {
-        return "";
-    }
-    const { text: protectedText, restore } = protectCodeBlocks(sanitized);
-    const lines = protectedText.split("\n").map((line) => line.trim());
-    const firstLine = lines[0] ?? "";
-    if (lines.length === 1 && firstLine.length < 80) {
-        const result = `${indent}/** ${firstLine} */\n`;
-        return restore(result, `${indent} * `);
-    }
-    const formattedLines = lines.map((line) => `${indent} * ${line}`);
-    const result = `${indent}/**\n${formattedLines.join("\n")}\n${indent} */\n`;
-    return restore(result, `${indent} * `);
-}
-export function formatMethodDoc(doc, params, indent = "  ", options = {}) {
-    const sanitizedDoc = doc ? sanitizeDoc(doc, options) : undefined;
-    const hasDocumentation = sanitizedDoc || params.some((p) => p.doc);
-    if (!hasDocumentation) {
-        return "";
-    }
-    const lines = [];
-    let protection;
-    if (sanitizedDoc) {
-        protection = protectCodeBlocks(sanitizedDoc);
-        for (const line of protection.text.split("\n")) {
-            lines.push(` * ${line.trim()}`);
-        }
-    }
-    for (const param of params) {
-        if (param.doc && param.name && param.name !== "..." && param.name !== "") {
-            const sanitizedParamDoc = sanitizeDoc(param.doc, options);
-            const paramDocFirstLine = sanitizedParamDoc.split("\n")[0]?.trim() ?? "";
-            lines.push(` * @param ${param.name} - ${paramDocFirstLine}`);
-        }
-    }
-    if (lines.length === 0) {
-        return "";
-    }
-    const result = `${indent}/**\n${indent}${lines.join(`\n${indent}`)}\n${indent} */\n`;
-    return protection ? protection.restore(result, `${indent} * `) : result;
-}

package/dist/naming.d.ts

@@ -1,6 +0,0 @@
-export declare const RESERVED_WORDS: Set<string>;
-export declare const toCamelCase: (str: string) => string;
-export declare const toPascalCase: (str: string) => string;
-export declare const toKebabCase: (str: string) => string;
-export declare const toConstantCase: (str: string) => string;
-export declare const toValidIdentifier: (str: string) => string;

package/dist/naming.js

@@ -1,69 +0,0 @@
-export const RESERVED_WORDS = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "new",
-    "null",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-    "yield",
-    "let",
-    "static",
-    "enum",
-    "implements",
-    "interface",
-    "package",
-    "private",
-    "protected",
-    "public",
-    "await",
-    "async",
-    "eval",
-    "arguments",
-]);
-export const toCamelCase = (str) => str.replace(/[-_]([a-z])/g, (_, letter) => letter.toUpperCase());
-export const toPascalCase = (str) => {
-    const camel = toCamelCase(str);
-    return camel.charAt(0).toUpperCase() + camel.slice(1);
-};
-export const toKebabCase = (str) => str
-    .replace(/([a-z])([A-Z])/g, "$1-$2")
-    .replace(/_/g, "-")
-    .toLowerCase();
-export const toConstantCase = (str) => str.replace(/-/g, "_").toUpperCase();
-export const toValidIdentifier = (str) => {
-    let result = str.replace(/[^a-zA-Z0-9_$]/g, "_");
-    if (RESERVED_WORDS.has(result))
-        result = `_${result}`;
-    if (/^\d/.test(result))
-        result = `_${result}`;
-    return result;
-};

package/dist/parser.d.ts

@@ -1,76 +0,0 @@
-/**
- * GObject Introspection XML (GIR) parser module.
- *
- * Parses GIR files to extract type information for GTK/GLib libraries.
- * Used by the code generator to create TypeScript bindings.
- *
- * @packageDocumentation
- */
-import type { GirNamespace } from "./types.js";
-/**
- * Parser for GObject Introspection XML (GIR) files.
- *
- * Converts GIR XML into structured TypeScript objects that can be used
- * for code generation. Handles all GIR elements including classes,
- * interfaces, functions, signals, properties, and type information.
- *
- * @example
- * ```tsx
- * import { GirParser } from "@gtkx/gir";
- * import { readFileSync } from "fs";
- *
- * const parser = new GirParser();
- * const xml = readFileSync("Gtk-4.0.gir", "utf-8");
- * const namespace = parser.parse(xml);
- *
- * console.log(namespace.name); // "Gtk"
- * console.log(namespace.classes.length); // Number of GTK classes
- * ```
- *
- * @see {@link GirNamespace} for the parsed output structure
- */
-export declare class GirParser {
-    private parser;
-    constructor();
-    /**
-     * Parses a GIR XML string into a structured namespace object.
-     *
-     * @param girXml - The raw XML content of a GIR file
-     * @returns A parsed namespace containing all type information
-     * @throws Error if the XML is missing required repository or namespace elements
-     *
-     * @example
-     * ```tsx
-     * const namespace = parser.parse(girXml);
-     *
-     * // Access parsed classes
-     * for (const cls of namespace.classes) {
-     *   console.log(`Class: ${cls.name}, Parent: ${cls.parent}`);
-     * }
-     *
-     * // Access parsed functions
-     * for (const fn of namespace.functions) {
-     *   console.log(`Function: ${fn.name} -> ${fn.returnType.name}`);
-     * }
-     * ```
-     */
-    parse(girXml: string): GirNamespace;
-    private parseCallbacks;
-    private parseClasses;
-    private parseImplements;
-    private parseInterfaces;
-    private parsePrerequisites;
-    private parseMethods;
-    private parseConstructors;
-    private parseFunctions;
-    private parseParameters;
-    private parseReturnType;
-    private parseType;
-    private parseProperties;
-    private parseSignals;
-    private parseRecords;
-    private parseFields;
-    private parseEnumerations;
-    private parseEnumerationMembers;
-    private parseConstants;
-}