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

package/src/store/gi/value-marshalable.ts

@@ -0,0 +1,96 @@
+import type { GirField } from "../../gir/field.js";
+import type { PrimitiveCategory } from "../../gir/primitives.js";
+import type { GirRecord } from "../../gir/record.js";
+import type { TypeId } from "../../gir/type-id.js";
+import type { GirType } from "../../gir/type.js";
+import type { ModuleContext } from "../../writer/context.js";
+
+type Scope = { context: ModuleContext; seen: Set<string> };
+
+/** Primitive categories that are a pointer at the C level, so copying the bytes aliases the pointee. */
+const POINTER_CATEGORIES: Set<PrimitiveCategory> = new Set<PrimitiveCategory>(["string", "pointer"]);
+
+const recordKey = (namespaceName: string, record: GirRecord): string => `${namespaceName}.${record.name}`;
+
+const hasOwnCopySemantics = (record: GirRecord): boolean =>
+    record.glibGetType !== undefined ||
+    ((record.glibRefFunc ?? record.copyFunc) !== undefined && (record.glibUnrefFunc ?? record.freeFunc) !== undefined);
+
+const isValueSafeArray = (scope: Scope, type: Extract<GirType, { kind: "carray" }>): boolean =>
+    type.fixedSize !== undefined && isValueSafeRef(scope, type.element, type.elementCType);
+
+const isValueSafeAlias = (scope: Scope, type: Extract<GirType, { kind: "alias" }>): boolean =>
+    isValueSafeRef(scope, type.value.target, type.value.targetCType);
+
+function isValueSafeType(scope: Scope, type: GirType): boolean {
+    switch (type.kind) {
+        case "primitive": {
+            return !POINTER_CATEGORIES.has(type.category);
+        }
+        case "enum": {
+            return true;
+        }
+        case "record": {
+            return isValueSafeRecord(scope, type.namespace.name, type.value);
+        }
+        case "carray": {
+            return isValueSafeArray(scope, type);
+        }
+        case "alias": {
+            return isValueSafeAlias(scope, type);
+        }
+        case "callback":
+        case "class":
+        case "hashtable":
+        case "interface":
+        case "list":
+        case "varargs": {
+            return false;
+        }
+    }
+}
+
+function isValueSafeRef(scope: Scope, ref: TypeId | undefined, cType: string | undefined): boolean {
+    if (ref === undefined || cType?.endsWith("*") === true) {
+        return false;
+    }
+
+    const type = scope.context.library.typeFor(ref);
+
+    return type === undefined ? false : isValueSafeType(scope, type);
+}
+
+const isValueSafeField = (scope: Scope, field: GirField): boolean =>
+    field.inlineMembers === undefined
+        ? isValueSafeRef(scope, field.type, field.cType)
+        : field.inlineMembers.every((member) => isValueSafeField(scope, member));
+
+function isValueSafeRecord(scope: Scope, namespaceName: string, record: GirRecord): boolean {
+    const key = recordKey(namespaceName, record);
+
+    if (scope.seen.has(key) || record.fields.length === 0) {
+        return false;
+    }
+
+    scope.seen.add(key);
+    const isSafe = record.fields.every((field) => isValueSafeField(scope, field));
+    scope.seen.delete(key);
+
+    return isSafe;
+}
+
+/**
+ * Whether a record can be copied by value. A plain struct is duplicated with a byte-wise `g_memdup2`,
+ * which shallow-copies whatever the bytes hold, so only a record whose every field is transitively a
+ * scalar can be owned, allocated or written into an inline slot. A pointer, a string, a function
+ * pointer or an opaque record makes it borrow-only. Records that carry their own copy/free pair are
+ * duplicated through that instead and never reach the byte-wise path.
+ */
+const isValueMarshalable = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
+    isValueSafeRecord({ context, seen: new Set<string>() }, namespaceName, record);
+
+/** Whether a record can be allocated and populated from JavaScript. */
+const isConstructibleRecord = (context: ModuleContext, namespaceName: string, record: GirRecord): boolean =>
+    hasOwnCopySemantics(record) || isValueMarshalable(context, namespaceName, record);
+
+export { hasOwnCopySemantics, isConstructibleRecord, isValueMarshalable };

package/src/store/jsx/intrinsic-elements.ts

@@ -214,14 +214,6 @@ const hasMatchingAncestorName = (
     isMatch: (glibName: string) => boolean,
 ): boolean => hasMatchingAncestor(klass, namespace, library, (_klass, glibName) => isMatch(glibName));
 
-const hasExposedMethod = (
-    klass: GirClass,
-    namespace: GirNamespace,
-    library: Library,
-    methodName: string,
-): boolean =>
-    hasMatchingAncestor(klass, namespace, library, (current) => current.methods.some((m) => m.name === methodName));
-
 const isIntrinsicElementClass = (klass: GirClass, namespace: GirNamespace, library: Library): boolean =>
     hasMatchingAncestorName(klass, namespace, library, (glibName) => glibName === "GObject");
 
@@ -253,7 +245,6 @@ export {
     newlyImplementedInterfaces,
     collectInterfacePropsClasses,
     ancestorGlibNames,
-    hasExposedMethod,
     isIntrinsicElementClass,
     collectIntrinsicElementClasses,
     type GlibNamedClass,

package/src/store/jsx/omitted-props.ts

@@ -0,0 +1,32 @@
+/** Props left out of the generated element props, keyed by GLib type name. */
+type OmittedProps = Record<string, string[]>;
+
+const omittedProps: Map<string, Set<string>> = new Map();
+
+/** Installs the props each element omits (GLib type name → prop names); set once per run. */
+const setOmittedProps = (props: OmittedProps): void => {
+    omittedProps.clear();
+
+    for (const [glibName, names] of Object.entries(props)) {
+        omittedProps.set(glibName, new Set(names));
+    }
+};
+
+/** Whether the element config declares this prop omitted for the type that declares the property. */
+const isOmittedProp = (glibName: string | undefined, jsName: string): boolean =>
+    glibName !== undefined && omittedProps.get(glibName)?.has(jsName) === true;
+
+/** Merges omitted-prop maps keyed by GLib type name, concatenating the names each map contributes. */
+const mergeOmitProps = (...maps: OmittedProps[]): OmittedProps => {
+    const merged: OmittedProps = {};
+
+    for (const map of maps) {
+        for (const [glibName, names] of Object.entries(map)) {
+            merged[glibName] = [...(merged[glibName] ?? []), ...names];
+        }
+    }
+
+    return merged;
+};
+
+export { setOmittedProps, isOmittedProp, mergeOmitProps, type OmittedProps };

package/src/store/jsx/pipeline.ts

@@ -9,6 +9,7 @@ import { buildGirIndex } from "./gir-index.js";
 import { collectIntrinsicElementClasses, type GlibNamedClass } from "./intrinsic-elements.js";
 import { generateJsxSection } from "./jsx.js";
 import { generateMetadata } from "./metadata.js";
+import { type OmittedProps, setOmittedProps } from "./omitted-props.js";
 
 type JsxNamespaceFile = {
     directory: string;
@@ -25,6 +26,7 @@ type JsxGenerationOptions = {
     reactSubexports?: string[];
     components?: ElementComponentOverrides;
     props?: ElementProps;
+    omitProps?: OmittedProps;
     lazyElements?: string[];
 };
 
@@ -47,6 +49,7 @@ type JsxNamespaceContext = {
 
 const generateJsxFiles = (library: Library, options: JsxGenerationOptions = {}): JsxFiles => {
     setElementProps(options.props ?? {});
+    setOmittedProps(options.omitProps ?? {});
     const intrinsicElements = collectIntrinsicElementClasses(library);
     const intrinsicElementByGlibName = new Map(intrinsicElements.map((entry) => [entry.glibName, entry]));
     const girIndex = buildGirIndex(library);

package/src/store/jsx/props.ts

@@ -9,12 +9,8 @@ import { renderHandlerParameters, renderHandlerResultType } from "../../analysis
 import { recordTypeTarget, renderBaseType, type TsTypeTarget } from "../../analysis/ts-type.js";
 import { type GirProperty, isConstructableProperty } from "../../gir/property.js";
 import { renderJsDoc } from "../../writer/doc.js";
-import {
-    giNamespaceAlias,
-    hasExposedMethod,
-    isIntrinsicElementClass,
-    signalHandlerName,
-} from "./intrinsic-elements.js";
+import { getGlibName, giNamespaceAlias, isIntrinsicElementClass, signalHandlerName } from "./intrinsic-elements.js";
+import { isOmittedProp } from "./omitted-props.js";
 
 type IntrinsicElementPropsEntries = {
     propLines: string[];
@@ -75,7 +71,7 @@ const appendPropertyLines = (state: PropCollectorState, property: GirProperty, j
     const tsType = renderReactPropType(state.types, property.type, false);
     const doc = renderJsDoc(property.doc);
 
-    if (isObjectProp(state.owner, property, jsName)) {
+    if (isObjectProp(state.owner.library, property)) {
         state.propLines.push(`${doc}${jsName}?: ${tsType} | ReactElement | null | undefined;`);
         state.objectPropNames.push(jsName);
 
@@ -99,7 +95,7 @@ const acceptCollectorProperty = (state: PropCollectorState, property: GirPropert
 
     const jsName = toCamelIdentifier(property.name);
 
-    if (state.seen.has(jsName)) {
+    if (state.seen.has(jsName) || isOmittedProp(getGlibName(state.owner.klass), jsName)) {
         return;
     }
 
@@ -215,20 +211,12 @@ const isGObjectType = (library: Library, ref: TypeId | undefined): boolean => {
     return isIntrinsicElementClass(resolved.value, resolved.namespace, library);
 };
 
-const isObjectProp = (owner: IntrinsicElementScope, property: GirProperty, jsName: string): boolean => {
+const isObjectProp = (library: Library, property: GirProperty): boolean => {
     if (!property.writable || property.constructOnly) {
         return false;
     }
 
-    if (!isGObjectType(owner.library, property.type)) {
-        return false;
-    }
-
-    if (jsName === "child" && hasExposedMethod(owner.klass, owner.namespace, owner.library, "set_child")) {
-        return false;
-    }
-
-    return true;
+    return isGObjectType(library, property.type);
 };
 
 const renderSignalHandler = (options: SignalRenderOptions): string => {

package/dist/store/gi/class-struct-record.d.ts

@@ -1,10 +0,0 @@
-import type { GirFunction } from "../../gir/function.js";
-import type { Library } from "../../gir/library.js";
-import type { GirRecord } from "../../gir/record.js";
-import type { TypeId } from "../../gir/type-id.js";
-import type { ModuleContext } from "../../writer/context.js";
-declare const isClassStructRecord: (library: Library, namespaceName: string, record: GirRecord) => boolean;
-declare const isClassStructRef: (context: ModuleContext, ref: TypeId | undefined) => boolean;
-declare const hasClassStructReference: (context: ModuleContext, fn: GirFunction) => boolean;
-export { isClassStructRecord, isClassStructRef, hasClassStructReference };
-//# sourceMappingURL=class-struct-record.d.ts.map

package/dist/store/gi/class-struct-record.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-struct-record.d.ts","sourceRoot":"","sources":["../../../src/store/gi/class-struct-record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAO7D,QAAA,MAAM,mBAAmB,GAAI,SAAS,OAAO,EAAE,eAAe,MAAM,EAAE,QAAQ,SAAS,KAAG,OAsBzF,CAAC;AAEF,QAAA,MAAM,gBAAgB,GAAI,SAAS,aAAa,EAAE,KAAK,MAAM,GAAG,SAAS,KAAG,OA8B3E,CAAC;AAEF,QAAA,MAAM,uBAAuB,GAAI,SAAS,aAAa,EAAE,IAAI,WAAW,KAAG,OAEK,CAAC;AAEjF,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/store/gi/class-struct-record.js

@@ -1,52 +0,0 @@
-const TYPE_STRUCT_ROOTS = new Set(["GObject.TypeClass", "GObject.TypeInterface"]);
-const EXPLICIT_CLASS_STRUCTS = new Set(["Pango.AttrClass"]);
-const qualify = (namespaceName, name) => `${namespaceName}.${name}`;
-const isClassStructRecord = (library, namespaceName, record) => {
-    const qualified = qualify(namespaceName, record.name);
-    if (TYPE_STRUCT_ROOTS.has(qualified) || EXPLICIT_CLASS_STRUCTS.has(qualified)) {
-        return true;
-    }
-    const first = record.fields[0];
-    // A class struct embeds its parent vtable by value (`GTypeClass g_type_class`); an instance
-    // struct stores a pointer to it (`GTypeClass *g_class`). Only the first is a vtable.
-    if (first?.type === undefined || first.cType?.endsWith("*") === true) {
-        return false;
-    }
-    const name = library.nameFor(first.type);
-    if (name === undefined) {
-        return false;
-    }
-    return TYPE_STRUCT_ROOTS.has(qualify(name.namespaceName, name.typeName));
-};
-const isClassStructRef = (context, ref) => {
-    if (ref === undefined) {
-        return false;
-    }
-    const type = context.library.typeFor(ref);
-    if (type === undefined) {
-        return false;
-    }
-    switch (type.kind) {
-        case "record": {
-            return isClassStructRecord(context.library, type.namespace.name, type.value);
-        }
-        case "carray":
-        case "list": {
-            return isClassStructRef(context, type.element);
-        }
-        case "alias":
-        case "callback":
-        case "class":
-        case "enum":
-        case "hashtable":
-        case "interface":
-        case "primitive":
-        case "varargs": {
-            return false;
-        }
-    }
-};
-const hasClassStructReference = (context, fn) => isClassStructRef(context, fn.returnValue.type) ||
-    fn.parameters.some((parameter) => isClassStructRef(context, parameter.type));
-export { isClassStructRecord, isClassStructRef, hasClassStructReference };
-//# sourceMappingURL=class-struct-record.js.map

package/dist/store/gi/class-struct-record.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"class-struct-record.js","sourceRoot":"","sources":["../../../src/store/gi/class-struct-record.ts"],"names":[],"mappings":"AAMA,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,mBAAmB,EAAE,uBAAuB,CAAC,CAAC,CAAC;AAClF,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC;AAE5D,MAAM,OAAO,GAAG,CAAC,aAAqB,EAAE,IAAY,EAAU,EAAE,CAAC,GAAG,aAAa,IAAI,IAAI,EAAE,CAAC;AAE5F,MAAM,mBAAmB,GAAG,CAAC,OAAgB,EAAE,aAAqB,EAAE,MAAiB,EAAW,EAAE;IAChG,MAAM,SAAS,GAAG,OAAO,CAAC,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtD,IAAI,iBAAiB,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,sBAAsB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QAC5E,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAE/B,4FAA4F;IAC5F,qFAAqF;IACrF,IAAI,KAAK,EAAE,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC;QACnE,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEzC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,OAAO,iBAAiB,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;AAC7E,CAAC,CAAC;AAEF,MAAM,gBAAgB,GAAG,CAAC,OAAsB,EAAE,GAAuB,EAAW,EAAE;IAClF,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAChB,KAAK,QAAQ,CAAC,CAAC,CAAC;YACZ,OAAO,mBAAmB,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACjF,CAAC;QACD,KAAK,QAAQ,CAAC;QACd,KAAK,MAAM,CAAC,CAAC,CAAC;YACV,OAAO,gBAAgB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;QACnD,CAAC;QACD,KAAK,OAAO,CAAC;QACb,KAAK,UAAU,CAAC;QAChB,KAAK,OAAO,CAAC;QACb,KAAK,MAAM,CAAC;QACZ,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW,CAAC;QACjB,KAAK,WAAW,CAAC;QACjB,KAAK,SAAS,CAAC,CAAC,CAAC;YACb,OAAO,KAAK,CAAC;QACjB,CAAC;IACL,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,uBAAuB,GAAG,CAAC,OAAsB,EAAE,EAAe,EAAW,EAAE,CACjF,gBAAgB,CAAC,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC;IAC9C,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,gBAAgB,CAAC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;AAEjF,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,CAAC","sourcesContent":["import type { GirFunction } from \"../../gir/function.js\";\nimport type { Library } from \"../../gir/library.js\";\nimport type { GirRecord } from \"../../gir/record.js\";\nimport type { TypeId } from \"../../gir/type-id.js\";\nimport type { ModuleContext } from \"../../writer/context.js\";\n\nconst TYPE_STRUCT_ROOTS = new Set([\"GObject.TypeClass\", \"GObject.TypeInterface\"]);\nconst EXPLICIT_CLASS_STRUCTS = new Set([\"Pango.AttrClass\"]);\n\nconst qualify = (namespaceName: string, name: string): string => `${namespaceName}.${name}`;\n\nconst isClassStructRecord = (library: Library, namespaceName: string, record: GirRecord): boolean => {\n    const qualified = qualify(namespaceName, record.name);\n\n    if (TYPE_STRUCT_ROOTS.has(qualified) || EXPLICIT_CLASS_STRUCTS.has(qualified)) {\n        return true;\n    }\n\n    const first = record.fields[0];\n\n    // A class struct embeds its parent vtable by value (`GTypeClass g_type_class`); an instance\n    // struct stores a pointer to it (`GTypeClass *g_class`). Only the first is a vtable.\n    if (first?.type === undefined || first.cType?.endsWith(\"*\") === true) {\n        return false;\n    }\n\n    const name = library.nameFor(first.type);\n\n    if (name === undefined) {\n        return false;\n    }\n\n    return TYPE_STRUCT_ROOTS.has(qualify(name.namespaceName, name.typeName));\n};\n\nconst isClassStructRef = (context: ModuleContext, ref: TypeId | undefined): boolean => {\n    if (ref === undefined) {\n        return false;\n    }\n\n    const type = context.library.typeFor(ref);\n\n    if (type === undefined) {\n        return false;\n    }\n\n    switch (type.kind) {\n        case \"record\": {\n            return isClassStructRecord(context.library, type.namespace.name, type.value);\n        }\n        case \"carray\":\n        case \"list\": {\n            return isClassStructRef(context, type.element);\n        }\n        case \"alias\":\n        case \"callback\":\n        case \"class\":\n        case \"enum\":\n        case \"hashtable\":\n        case \"interface\":\n        case \"primitive\":\n        case \"varargs\": {\n            return false;\n        }\n    }\n};\n\nconst hasClassStructReference = (context: ModuleContext, fn: GirFunction): boolean =>\n    isClassStructRef(context, fn.returnValue.type) ||\n    fn.parameters.some((parameter) => isClassStructRef(context, parameter.type));\n\nexport { isClassStructRecord, isClassStructRef, hasClassStructReference };\n"]}

package/src/store/gi/class-struct-record.ts

@@ -1,72 +0,0 @@
-import type { GirFunction } from "../../gir/function.js";
-import type { Library } from "../../gir/library.js";
-import type { GirRecord } from "../../gir/record.js";
-import type { TypeId } from "../../gir/type-id.js";
-import type { ModuleContext } from "../../writer/context.js";
-
-const TYPE_STRUCT_ROOTS = new Set(["GObject.TypeClass", "GObject.TypeInterface"]);
-const EXPLICIT_CLASS_STRUCTS = new Set(["Pango.AttrClass"]);
-
-const qualify = (namespaceName: string, name: string): string => `${namespaceName}.${name}`;
-
-const isClassStructRecord = (library: Library, namespaceName: string, record: GirRecord): boolean => {
-    const qualified = qualify(namespaceName, record.name);
-
-    if (TYPE_STRUCT_ROOTS.has(qualified) || EXPLICIT_CLASS_STRUCTS.has(qualified)) {
-        return true;
-    }
-
-    const first = record.fields[0];
-
-    // A class struct embeds its parent vtable by value (`GTypeClass g_type_class`); an instance
-    // struct stores a pointer to it (`GTypeClass *g_class`). Only the first is a vtable.
-    if (first?.type === undefined || first.cType?.endsWith("*") === true) {
-        return false;
-    }
-
-    const name = library.nameFor(first.type);
-
-    if (name === undefined) {
-        return false;
-    }
-
-    return TYPE_STRUCT_ROOTS.has(qualify(name.namespaceName, name.typeName));
-};
-
-const isClassStructRef = (context: ModuleContext, ref: TypeId | undefined): boolean => {
-    if (ref === undefined) {
-        return false;
-    }
-
-    const type = context.library.typeFor(ref);
-
-    if (type === undefined) {
-        return false;
-    }
-
-    switch (type.kind) {
-        case "record": {
-            return isClassStructRecord(context.library, type.namespace.name, type.value);
-        }
-        case "carray":
-        case "list": {
-            return isClassStructRef(context, type.element);
-        }
-        case "alias":
-        case "callback":
-        case "class":
-        case "enum":
-        case "hashtable":
-        case "interface":
-        case "primitive":
-        case "varargs": {
-            return false;
-        }
-    }
-};
-
-const hasClassStructReference = (context: ModuleContext, fn: GirFunction): boolean =>
-    isClassStructRef(context, fn.returnValue.type) ||
-    fn.parameters.some((parameter) => isClassStructRef(context, parameter.type));
-
-export { isClassStructRecord, isClassStructRef, hasClassStructReference };