@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.3

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

@@ -1,280 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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),
-    );