@gtkx/codegen 0.21.0 → 1.0.0-rc.1

package/src/store/react/element-prop-types.ts

@@ -0,0 +1,280 @@
+import type { AppliedProp, Call, ContainerProp, ElementProp } from "@gtkx/config";
+import { toCamelIdentifier } from "@gtkx/utils";
+import { renderBaseTypeFor } from "../../analysis/ts-type.js";
+import type { GirClass } from "../../gir/class.js";
+import type { GirNamespace } from "../../gir/namespace.js";
+import type { GirParameter } from "../../gir/parameter.js";
+import { chainOf, findMethod, type GirIndex, type GirTypeEntry, hasProperty } from "./gir-index.js";
+import { glibNameOf } from "./intrinsic-elements.js";
+import { reactTarget } from "./props.js";
+
+type TypeImports = Map<string, string>;
+
+type PropContribution = {
+    child: string;
+    prop: string;
+    param: GirParameter;
+};
+
+export type LazyElementSpec = {
+    element: string;
+    typeName: string;
+    typeSource: string;
+};
+
+export type ElementPropTypegen = {
+    classPropLines: (glibName: string, klass: GirClass, namespace: GirNamespace, imports: TypeImports) => string[];
+    lazyElementExports: (namespaceName: string) => LazyElementSpec[];
+    containerPropNamesFor: (glibName: string) => string[];
+    acceptsChildren: (glibName: string) => boolean;
+};
+
+const forEachContainer = (
+    elementProps: Record<string, ElementProp[]>,
+    visit: (type: string, prop: ContainerProp) => void,
+): void => {
+    for (const [type, props] of Object.entries(elementProps)) {
+        for (const prop of props) {
+            if (prop.kind === "container") visit(type, prop);
+        }
+    }
+};
+
+const renderParamType = (context: GirIndex, imports: TypeImports, param: GirParameter | undefined): string => {
+    if (param === undefined) return "unknown";
+    const base = renderBaseTypeFor(context.library, reactTarget({ library: context.library, imports }), param.type);
+    return param.nullable || param.optional ? `${base} | null` : base;
+};
+
+const optionalLine = (prop: string, type: string): string => {
+    const withNull = type.endsWith(" | null") ? type : `${type} | null`;
+    return `${prop}?: ${withNull} | undefined;`;
+};
+
+type FieldLine = { field: string; text: string };
+
+const callFieldLines = (context: GirIndex, imports: TypeImports, type: string, call: Call): FieldLine[] => {
+    if (typeof call === "string") return [];
+    const method = findMethod(context, type, call.method);
+    const lines: FieldLine[] = [];
+    call.args.forEach((arg, positionIndex) => {
+        if (typeof arg !== "object" || !("field" in arg)) return;
+        const param = method?.params[positionIndex];
+        const optional = "or" in arg || param?.nullable === true || param?.optional === true;
+        lines.push({
+            field: arg.field,
+            text: `${arg.field}${optional ? "?" : ""}: ${renderParamType(context, imports, param)};`,
+        });
+    });
+    return lines;
+};
+
+const mergedFieldsType = (lines: FieldLine[]): string => {
+    const seen = new Set<string>();
+    const texts: string[] = [];
+    for (const line of lines) {
+        if (seen.has(line.field)) continue;
+        seen.add(line.field);
+        texts.push(line.text);
+    }
+    return `{ ${texts.join(" ")} }`;
+};
+
+const callFieldsType = (context: GirIndex, imports: TypeImports, type: string, call: Call | Call[]): string => {
+    if (Array.isArray(call))
+        return mergedFieldsType(call.flatMap((entry) => callFieldLines(context, imports, type, entry)));
+    if (typeof call === "string") {
+        const method = findMethod(context, type, call);
+        return renderParamType(context, imports, method?.params[0]);
+    }
+    const lines = callFieldLines(context, imports, type, call);
+    if (lines.length > 0) return mergedFieldsType(lines);
+    const method = findMethod(context, type, call.method);
+    return renderParamType(context, imports, method?.params[0]);
+};
+
+const appliedPropLine = (context: GirIndex, imports: TypeImports, type: string, prop: AppliedProp): string | null => {
+    if (hasProperty(context, type, prop.prop)) return null;
+    if (prop.kind === "value") return optionalLine(prop.prop, callFieldsType(context, imports, type, prop.call));
+    if (prop.kind === "list") return optionalLine(prop.prop, `${callFieldsType(context, imports, type, prop.add)}[]`);
+    return null;
+};
+
+const collectCallContributions = (
+    context: GirIndex,
+    contributions: PropContribution[],
+    container: { parent: string; child: string },
+    call: Exclude<ContainerProp["append"], string | undefined>,
+): void => {
+    const method = findMethod(context, container.parent, call.method);
+    call.args.forEach((arg, positionIndex) => {
+        if (typeof arg !== "object" || !("prop" in arg)) return;
+        const param = method?.params[positionIndex];
+        if (param === undefined) return;
+        if (hasProperty(context, container.child, arg.prop)) return;
+        if (contributions.some((entry) => entry.child === container.child && entry.prop === arg.prop)) return;
+        contributions.push({ child: container.child, prop: arg.prop, param });
+    });
+};
+
+const collectPropContributions = (
+    context: GirIndex,
+    elementProps: Record<string, ElementProp[]>,
+): PropContribution[] => {
+    const contributions: PropContribution[] = [];
+    forEachContainer(elementProps, (parent, cp) => {
+        for (const call of [cp.append, cp.remove, cp.insert, cp.reorder]) {
+            if (call === undefined || typeof call === "string") continue;
+            collectCallContributions(context, contributions, { parent, child: cp.child }, call);
+        }
+    });
+    return contributions;
+};
+
+const directTypeNames = (context: GirIndex, klass: GirClass, namespace: GirNamespace): Set<string> => {
+    const names = new Set<string>();
+    const glibName = glibNameOf(klass);
+    if (glibName !== undefined) names.add(glibName);
+    for (const name of klass.implements) {
+        const resolved = context.library.resolveType(namespace.name, name);
+        if (resolved === undefined || resolved.kind !== "interface") continue;
+        const ifaceGlib = glibNameOf(resolved.value);
+        if (ifaceGlib !== undefined) names.add(ifaceGlib);
+    }
+    return names;
+};
+
+const constructOnlyNames = (context: GirIndex, entry: GirTypeEntry): string[] => {
+    const names: string[] = [];
+    for (const klass of chainOf(context, entry)) {
+        for (const property of klass.properties) {
+            if (property.constructOnly) names.push(toCamelIdentifier(property.name));
+        }
+    }
+    return names;
+};
+
+const methodReturnGlib = (context: GirIndex, typeName: string, methodCamel: string): string | undefined => {
+    const method = findMethod(context, typeName, methodCamel);
+    const ref = method?.fn.returnValue.type;
+    if (ref === undefined) return undefined;
+    const resolved = context.library.typeOf(ref);
+    if (resolved === undefined || resolved.kind !== "class") return undefined;
+    return glibNameOf(resolved.value);
+};
+
+const resolveAdoptElement = (context: GirIndex, parent: string, cp: ContainerProp): string | undefined => {
+    if (cp.adopt === undefined) return undefined;
+    const source = typeof cp.adopt === "string" ? cp.adopt : cp.append;
+    if (source === undefined) return undefined;
+    const method = typeof source === "string" ? source : source.method;
+    return methodReturnGlib(context, parent, method);
+};
+
+const lazyElementExportOf = (context: GirIndex, element: string): LazyElementSpec => {
+    const typeName = `${element}ElementProps`;
+    const elementClass = context.index.get(element);
+    if (elementClass === undefined) {
+        return { element, typeName, typeSource: `export type ${typeName} = { children?: ReactNode };` };
+    }
+    const baseName = glibNameOf(elementClass.klass) ?? element;
+    const omitted = constructOnlyNames(context, elementClass);
+    const omitUnion = omitted.map((name) => JSON.stringify(name)).join(" | ");
+    const base = omitted.length === 0 ? `${baseName}Props` : `Omit<${baseName}Props, ${omitUnion}>`;
+    return { element, typeName, typeSource: `export type ${typeName} = ${base};` };
+};
+
+const collectLazyElementSpecs = (
+    context: GirIndex,
+    elementProps: Record<string, ElementProp[]>,
+): Map<string, LazyElementSpec[]> => {
+    const specs = new Map<string, LazyElementSpec[]>();
+    forEachContainer(elementProps, (parent, cp) => {
+        const parentEntry = context.index.get(parent);
+        if (parentEntry === undefined) return;
+        const element = resolveAdoptElement(context, parent, cp);
+        if (element === undefined) return;
+        const spec = lazyElementExportOf(context, element);
+        const list = specs.get(parentEntry.namespace.name) ?? [];
+        if (!list.some((existing) => existing.element === spec.element)) list.push(spec);
+        specs.set(parentEntry.namespace.name, list);
+    });
+    return specs;
+};
+
+const collectContainerPropNames = (elementProps: Record<string, ElementProp[]>): Map<string, string[]> => {
+    const containerPropNamesByParent = new Map<string, string[]>();
+    forEachContainer(elementProps, (parent, cp) => {
+        if (cp.prop === "children") return;
+        const names = containerPropNamesByParent.get(parent) ?? [];
+        if (!names.includes(cp.prop)) names.push(cp.prop);
+        containerPropNamesByParent.set(parent, names);
+    });
+    return containerPropNamesByParent;
+};
+
+const TEXT_CONTAINERS = ["GtkLabel", "GtkTextBuffer", "GtkTextTag", "GtkTextView"];
+
+export const createElementPropTypegen = (
+    context: GirIndex,
+    elementProps: Record<string, ElementProp[]>,
+): ElementPropTypegen => {
+    const appliedByType = new Map<string, AppliedProp[]>();
+    for (const [type, props] of Object.entries(elementProps)) {
+        for (const prop of props) {
+            if (prop.kind === "container") continue;
+            const list = appliedByType.get(type) ?? [];
+            list.push(prop);
+            appliedByType.set(type, list);
+        }
+    }
+
+    const propContributions = collectPropContributions(context, elementProps);
+    const lazyElementSpecs = collectLazyElementSpecs(context, elementProps);
+    const containerPropNamesByParent = collectContainerPropNames(elementProps);
+
+    const childrenContainers = new Set<string>(TEXT_CONTAINERS);
+    forEachContainer(elementProps, (parent, cp) => {
+        if (cp.prop === "children") childrenContainers.add(parent);
+        const element = resolveAdoptElement(context, parent, cp);
+        if (element !== undefined) childrenContainers.add(element);
+    });
+
+    const acceptsChildren = (glibName: string): boolean => {
+        if (childrenContainers.has(glibName)) return true;
+        const entry = context.index.get(glibName);
+        if (entry === undefined) return false;
+        const chain = chainOf(context, entry);
+        if (chain.some((klass) => glibNameOf(klass) === "GtkWidget")) return true;
+        return chain.some((klass) => {
+            const name = glibNameOf(klass);
+            return name !== undefined && childrenContainers.has(name);
+        });
+    };
+
+    const classPropLines = (
+        glibName: string,
+        klass: GirClass,
+        namespace: GirNamespace,
+        imports: TypeImports,
+    ): string[] => {
+        const lines: string[] = [];
+        for (const prop of appliedByType.get(glibName) ?? []) {
+            const line = appliedPropLine(context, imports, glibName, prop);
+            if (line !== null) lines.push(line);
+        }
+        const direct = directTypeNames(context, klass, namespace);
+        for (const contribution of propContributions) {
+            if (!direct.has(contribution.child)) continue;
+            lines.push(optionalLine(contribution.prop, renderParamType(context, imports, contribution.param)));
+        }
+        return lines;
+    };
+
+    return {
+        classPropLines,
+        lazyElementExports: (namespaceName) => lazyElementSpecs.get(namespaceName) ?? [],
+        containerPropNamesFor: (glibName) => containerPropNamesByParent.get(glibName) ?? [],
+        acceptsChildren,
+    };
+};

package/src/store/react/element-props.ts

@@ -0,0 +1,204 @@
+import type { Arg, Call, ContainerProp, ElementProp, ListProp, ValueProp } from "@gtkx/config";
+import { toCamelIdentifier } from "@gtkx/utils";
+import type { GirParameter } from "../../gir/parameter.js";
+import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
+import { BUILT_IN_ELEMENT_PROPS } from "./built-ins.js";
+import { findMethod, type GirIndex, hasMethod, hasProperty } from "./gir-index.js";
+
+const callMethodName = (call: Call): string => (typeof call === "string" ? call : call.method);
+
+const containerTypeNames = (parent: string, prop: ContainerProp): string[] => {
+    const names = [parent, prop.child];
+    if (prop.autowrap !== undefined) names.push(prop.autowrap);
+    return names;
+};
+
+const containerCalls = (prop: ContainerProp): Call[] => {
+    const calls = [prop.append, prop.remove, prop.insert, prop.reorder].filter(
+        (call): call is Call => call !== undefined,
+    );
+    if (typeof prop.adopt === "string") calls.push(prop.adopt);
+    return calls;
+};
+
+const knownTypes = (context: GirIndex, names: string[]): boolean => names.every((name) => context.index.has(name));
+
+const elementPropError = (path: string, message: string): Error => new Error(`gtkx.config.ts: \`${path}\` ${message}`);
+
+const validateTypeNames = (context: GirIndex, path: string, names: string[]): void => {
+    for (const name of names) {
+        if (!context.index.has(name)) {
+            throw elementPropError(path, `references "${name}", which is not a type in the generated libraries`);
+        }
+    }
+};
+
+const validateCalls = (context: GirIndex, path: string, host: string, calls: Call[]): void => {
+    for (const call of calls) {
+        const method = callMethodName(call);
+        if (!hasMethod(context, host, method)) {
+            throw elementPropError(path, `references method "${method}", which does not exist on ${host}`);
+        }
+    }
+};
+
+const validateMember = (context: GirIndex, path: string, host: string, name: string): void => {
+    if (!hasProperty(context, host, name)) {
+        throw elementPropError(path, `references "${name}", which is not a property of ${host}`);
+    }
+};
+
+const validateUserElementProp = (context: GirIndex, type: string, path: string, prop: ElementProp): void => {
+    switch (prop.kind) {
+        case "container":
+            validateTypeNames(context, path, containerTypeNames(type, prop));
+            validateCalls(context, path, type, containerCalls(prop));
+            return;
+        case "value":
+            validateTypeNames(context, path, [type]);
+            validateCalls(context, path, type, prop.after === undefined ? [prop.call] : [prop.call, prop.after]);
+            return;
+        case "controlled-text":
+            validateTypeNames(context, path, [type]);
+            validateMember(context, path, type, prop.prop);
+            return;
+        case "lazy":
+            validateTypeNames(context, path, [type]);
+            validateMember(context, path, type, prop.prop);
+            if (prop.lookup !== undefined) validateCalls(context, path, type, [prop.lookup]);
+            return;
+        case "list":
+            validateTypeNames(context, path, [type]);
+            validateCalls(context, path, type, listCalls(prop));
+            return;
+    }
+};
+
+const addCalls = (add: ListProp["add"]): Call[] => (Array.isArray(add) ? add : [add]);
+
+const listCalls = (prop: ListProp): Call[] => {
+    const calls = addCalls(prop.add);
+    if (prop.remove !== undefined) calls.push(prop.remove);
+    if (prop.clear !== undefined) calls.push(prop.clear);
+    return calls;
+};
+
+const NO_DEFAULT = Symbol("gtkx.no-default");
+
+const inferredDefault = (context: GirIndex, param: GirParameter): null | number | boolean | typeof NO_DEFAULT => {
+    if (param.nullable) return null;
+    const type = param.type === undefined ? undefined : context.library.typeOf(param.type);
+    if (type?.kind !== "primitive") return NO_DEFAULT;
+    switch (PRIMITIVE_TS_TYPE[type.category]) {
+        case "number":
+            return 0;
+        case "boolean":
+            return false;
+        default:
+            return NO_DEFAULT;
+    }
+};
+
+const argForParameter = (context: GirIndex, param: GirParameter): Arg => {
+    const field = toCamelIdentifier(param.name);
+    const or = inferredDefault(context, param);
+    return or === NO_DEFAULT ? { field } : { field, or };
+};
+
+const callArity = (context: GirIndex, type: string, call: Call): number | undefined =>
+    typeof call === "string" ? findMethod(context, type, call)?.params.length : undefined;
+
+const expandCall = (context: GirIndex, type: string, call: Call, scalar: boolean): Call => {
+    if (typeof call !== "string" || scalar) return call;
+    const method = findMethod(context, type, call);
+    if (method === undefined || method.params.length === 0) return call;
+    return { method: call, args: method.params.map((param) => argForParameter(context, param)) };
+};
+
+const expandListProp = (context: GirIndex, type: string, prop: ListProp): ListProp => {
+    const scalar = !Array.isArray(prop.add) && callArity(context, type, prop.add) === 1;
+    const add = Array.isArray(prop.add)
+        ? prop.add.map((call) => expandCall(context, type, call, false))
+        : expandCall(context, type, prop.add, scalar);
+    return {
+        ...prop,
+        add,
+        remove: prop.remove === undefined ? undefined : expandCall(context, type, prop.remove, scalar),
+    };
+};
+
+const expandValueProp = (context: GirIndex, type: string, prop: ValueProp): ValueProp => {
+    const arity = callArity(context, type, prop.call);
+    return { ...prop, call: expandCall(context, type, prop.call, arity === undefined || arity <= 1) };
+};
+
+const expandAppliedProps = (
+    context: GirIndex,
+    elementProps: Record<string, ElementProp[]>,
+): Record<string, ElementProp[]> => {
+    const result: Record<string, ElementProp[]> = {};
+    for (const [type, props] of Object.entries(elementProps)) {
+        result[type] = props.map((prop) => {
+            if (prop.kind === "list") return expandListProp(context, type, prop);
+            if (prop.kind === "value") return expandValueProp(context, type, prop);
+            return prop;
+        });
+    }
+    return result;
+};
+
+const validateUserElementProps = (context: GirIndex, elementProps: Record<string, ElementProp[]>): void => {
+    for (const [type, props] of Object.entries(elementProps)) {
+        props.forEach((prop, index) => {
+            validateUserElementProp(context, type, `elementProps.${type}[${index}]`, prop);
+        });
+    }
+};
+
+const elementPropKey = (prop: ElementProp): string =>
+    prop.kind === "container" ? `container:${prop.prop}:${prop.child}` : `applied:${prop.prop}`;
+
+const mergeElementProps = (layers: Record<string, ElementProp[]>[]): Record<string, ElementProp[]> => {
+    const byType = new Map<string, Map<string, ElementProp>>();
+    for (const layer of layers) {
+        for (const [type, props] of Object.entries(layer)) {
+            const merged = byType.get(type) ?? new Map<string, ElementProp>();
+            for (const prop of props) {
+                const key = elementPropKey(prop);
+                merged.delete(key);
+                merged.set(key, prop);
+            }
+            byType.set(type, merged);
+        }
+    }
+    const result: Record<string, ElementProp[]> = {};
+    for (const [type, merged] of byType) result[type] = [...merged.values()];
+    return result;
+};
+
+const filterKnownElementProps = (
+    context: GirIndex,
+    map: Record<string, ElementProp[]>,
+): Record<string, ElementProp[]> => {
+    const result: Record<string, ElementProp[]> = {};
+    for (const [type, props] of Object.entries(map)) {
+        if (!context.index.has(type)) continue;
+        const kept = props.filter(
+            (prop) => prop.kind !== "container" || knownTypes(context, containerTypeNames(type, prop)),
+        );
+        if (kept.length > 0) result[type] = kept;
+    }
+    return result;
+};
+
+export const assembleElementProps = (
+    context: GirIndex,
+    userElementProps: Record<string, ElementProp[]>,
+): Record<string, ElementProp[]> => {
+    validateUserElementProps(context, userElementProps);
+    const merged = mergeElementProps([
+        filterKnownElementProps(context, BUILT_IN_ELEMENT_PROPS),
+        filterKnownElementProps(context, userElementProps),
+    ]);
+    return expandAppliedProps(context, merged);
+};

package/src/store/react/gir-index.ts

@@ -0,0 +1,85 @@
+import { toCamelIdentifier } from "@gtkx/utils";
+import { inputParameters } from "../../analysis/param-structure.js";
+import { ancestorChain } from "../../gir/ancestry.js";
+import type { GirClass } from "../../gir/class.js";
+import type { GirFunction } from "../../gir/function.js";
+import type { Library } from "../../gir/library.js";
+import type { GirNamespace } from "../../gir/namespace.js";
+import type { GirParameter } from "../../gir/parameter.js";
+import { glibNameOf, implementedInterfaces } from "./intrinsic-elements.js";
+
+export type GirTypeEntry = {
+    klass: GirClass;
+    namespace: GirNamespace;
+    isInterface: boolean;
+};
+
+export type GirIndex = {
+    library: Library;
+    index: Map<string, GirTypeEntry>;
+};
+
+export const buildGirIndex = (library: Library): GirIndex => {
+    const index = new Map<string, GirTypeEntry>();
+    for (const namespace of library.namespaces.values()) {
+        for (const klass of namespace.classes) {
+            const glibName = glibNameOf(klass);
+            if (glibName !== undefined && !index.has(glibName)) {
+                index.set(glibName, { klass, namespace, isInterface: false });
+            }
+        }
+        for (const klass of namespace.interfaces) {
+            const glibName = glibNameOf(klass);
+            if (glibName !== undefined && !index.has(glibName)) {
+                index.set(glibName, { klass, namespace, isInterface: true });
+            }
+        }
+    }
+    return { library, index };
+};
+
+export const chainOf = (context: GirIndex, entry: GirTypeEntry): GirClass[] => {
+    if (entry.isInterface) return [entry.klass];
+    const chain: GirClass[] = [];
+    for (const { klass } of ancestorChain(context.library, entry.klass, entry.namespace.name)) chain.push(klass);
+    for (const iface of implementedInterfaces(entry.klass, entry.namespace, context.library)) chain.push(iface.klass);
+    return chain;
+};
+
+type ResolvedMethod = {
+    fn: GirFunction;
+    params: GirParameter[];
+};
+
+export const findMethod = (context: GirIndex, typeName: string, camelName: string): ResolvedMethod | undefined => {
+    const entry = context.index.get(typeName);
+    if (entry === undefined) return undefined;
+    for (const klass of chainOf(context, entry)) {
+        const fn = klass.methods.find(
+            (method) =>
+                method.introspectable &&
+                method.shadowedBy === undefined &&
+                toCamelIdentifier(method.name) === camelName,
+        );
+        if (fn !== undefined) {
+            return { fn, params: inputParameters(context.library, fn).map((input) => input.parameter) };
+        }
+    }
+    return undefined;
+};
+
+const chainSome = (context: GirIndex, typeName: string, predicate: (klass: GirClass) => boolean): boolean => {
+    const entry = context.index.get(typeName);
+    if (entry === undefined) return false;
+    return chainOf(context, entry).some(predicate);
+};
+
+export const hasMethod = (context: GirIndex, typeName: string, camelName: string): boolean =>
+    chainSome(context, typeName, (klass) =>
+        klass.methods.some((method) => method.introspectable && toCamelIdentifier(method.name) === camelName),
+    );
+
+export const hasProperty = (context: GirIndex, typeName: string, camelName: string): boolean =>
+    chainSome(context, typeName, (klass) =>
+        klass.properties.some((property) => toCamelIdentifier(property.name) === camelName),
+    );