@gtkx/codegen 1.2.1 → 1.3.0

package/src/store/external-package-links.ts

@@ -0,0 +1,226 @@
+import { existsSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { EXTERNAL_NAMESPACES, type ExternalNamespace } from "../gir/external-namespaces.js";
+import { nodeModulesChain } from "./resolve-store.js";
+import { type StoreLink, symlinkRelative } from "./store-fs.js";
+
+type ExternalPackageSource = "store" | "hoisted" | "codegen";
+
+type ExternalPackageResolution = {
+    packageName: string;
+    directory: string;
+    dir: string;
+    source: ExternalPackageSource;
+};
+
+const DEPENDENCY_FIELDS = ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
+const codegenRequire = createRequire(import.meta.url);
+const codegenPackageDirs: Map<string, string | undefined> = new Map();
+const ensuredStores: Set<string> = new Set();
+
+const storeAnchor = (link: StoreLink): string => dirname(dirname(link.linkDir));
+const namespaceShimDirectory = (entry: ExternalNamespace): string => entry.namespace.toLowerCase();
+
+const resolveFromStore = (link: StoreLink, packageName: string): string | undefined => {
+    const chain = nodeModulesChain(dirname(storeAnchor(link)));
+
+    for (const nodeModules of chain) {
+        const manifest = join(nodeModules, packageName, "package.json");
+
+        if (existsSync(manifest)) {
+            return dirname(realpathSync(manifest));
+        }
+    }
+
+    return undefined;
+};
+
+const projectManifestPath = (link: StoreLink): string => join(dirname(storeAnchor(link)), "package.json");
+
+const readManifest = (manifestPath: string): Record<string, unknown> | undefined => {
+    try {
+        return JSON.parse(readFileSync(manifestPath, "utf8")) as Record<string, unknown>;
+    } catch {
+        return undefined;
+    }
+};
+
+const sectionNames = (section: unknown): string[] =>
+    typeof section === "object" && section !== null ? Object.keys(section) : [];
+
+const declaredDependencies = (manifest: Record<string, unknown>): Set<string> =>
+    new Set(DEPENDENCY_FIELDS.flatMap((field) => sectionNames(manifest[field])));
+
+const isDeclaredByProject = (link: StoreLink, packageName: string): boolean => {
+    const manifest = readManifest(projectManifestPath(link));
+
+    return manifest === undefined || declaredDependencies(manifest).has(packageName);
+};
+
+const resolveFromCodegen = (packageName: string): string | undefined => {
+    if (codegenPackageDirs.has(packageName)) {
+        return codegenPackageDirs.get(packageName);
+    }
+
+    let dir: string | undefined;
+
+    try {
+        dir = dirname(realpathSync(codegenRequire.resolve(`${packageName}/package.json`)));
+    } catch {
+        dir = undefined;
+    }
+
+    codegenPackageDirs.set(packageName, dir);
+
+    return dir;
+};
+
+const resolveEntry = (link: StoreLink, entry: ExternalNamespace): ExternalPackageResolution | undefined => {
+    const directory = namespaceShimDirectory(entry);
+    const chainResolved = resolveFromStore(link, entry.packageName);
+
+    if (chainResolved !== undefined) {
+        const source = isDeclaredByProject(link, entry.packageName) ? "store" : "hoisted";
+
+        return { packageName: entry.packageName, directory, dir: chainResolved, source };
+    }
+
+    const codegenDir = resolveFromCodegen(entry.packageName);
+
+    if (codegenDir !== undefined) {
+        return { packageName: entry.packageName, directory, dir: codegenDir, source: "codegen" };
+    }
+
+    return undefined;
+};
+
+const resolveExternalPackages = (link: StoreLink): ExternalPackageResolution[] => {
+    const resolutions: ExternalPackageResolution[] = [];
+
+    for (const entry of EXTERNAL_NAMESPACES) {
+        const resolution = resolveEntry(link, entry);
+
+        if (resolution !== undefined) {
+            resolutions.push(resolution);
+        }
+    }
+
+    return resolutions;
+};
+
+const isLinkedTo = (linkPath: string, dir: string): boolean => {
+    try {
+        return realpathSync(linkPath) === realpathSync(dir);
+    } catch {
+        return false;
+    }
+};
+
+const applyLink = (storeDir: string, resolution: ExternalPackageResolution): void => {
+    const linkPath = join(storeDir, "node_modules", resolution.packageName);
+
+    if (resolution.source === "codegen") {
+        if (!isLinkedTo(linkPath, resolution.dir)) {
+            symlinkRelative(linkPath, resolution.dir);
+        }
+
+        return;
+    }
+
+    rmSync(linkPath, { recursive: true, force: true });
+};
+
+const tryApplyLink = (storeDir: string, resolution: ExternalPackageResolution): void => {
+    try {
+        applyLink(storeDir, resolution);
+    } catch {
+        return;
+    }
+};
+
+const ensureExternalPackageLinks = (link: StoreLink): void => {
+    if (ensuredStores.has(link.storeDir)) {
+        return;
+    }
+
+    if (!existsSync(join(link.storeDir, "package.json"))) {
+        return;
+    }
+
+    for (const resolution of resolveExternalPackages(link)) {
+        tryApplyLink(link.storeDir, resolution);
+    }
+
+    ensuredStores.add(link.storeDir);
+};
+
+const resetExternalPackageLinks = (storeDir: string): void => {
+    ensuredStores.delete(storeDir);
+};
+
+const externalPackageNotice = (resolution: ExternalPackageResolution): string =>
+    `${resolution.packageName} is not installed in this project, so the copy @gtkx/codegen depends on was ` +
+    `linked into the generated store; add ${resolution.packageName} to your dependencies, because GTKX 2.0 ` +
+    "stops doing this.";
+
+const hoistedPackageNotice = (resolution: ExternalPackageResolution): string =>
+    `${resolution.packageName} is not declared in this project's package.json and only resolves because ` +
+    `your package manager hoisted it; add ${resolution.packageName} to your dependencies, because GTKX 2.0 ` +
+    "requires the direct dependency.";
+
+const hasShim = (storeDir: string, entry: ExternalNamespace): boolean =>
+    existsSync(join(storeDir, namespaceShimDirectory(entry), "index.js"));
+
+const hasStoreLocalLink = (storeDir: string, packageName: string): boolean =>
+    existsSync(join(storeDir, "node_modules", packageName, "package.json"));
+
+const unresolvableMessage = (link: StoreLink, entry: ExternalNamespace): string =>
+    `Cannot resolve ${entry.packageName} from ${storeAnchor(link)} or from @gtkx/codegen; ` +
+    "install it next to @gtkx/runtime.";
+
+const linkFailedMessage = (link: StoreLink, entry: ExternalNamespace): string =>
+    `Cannot link ${entry.packageName} into the generated store at ${link.storeDir}; ` +
+    `install ${entry.packageName} next to @gtkx/runtime.`;
+
+const entryNotice = (link: StoreLink, entry: ExternalNamespace): string | undefined => {
+    if (!hasShim(link.storeDir, entry)) {
+        return undefined;
+    }
+
+    const resolution = resolveEntry(link, entry);
+
+    if (resolution === undefined) {
+        throw new Error(unresolvableMessage(link, entry));
+    }
+
+    if (resolution.source === "store") {
+        return undefined;
+    }
+
+    if (resolution.source === "hoisted") {
+        return hoistedPackageNotice(resolution);
+    }
+
+    if (!hasStoreLocalLink(link.storeDir, resolution.packageName)) {
+        throw new Error(linkFailedMessage(link, entry));
+    }
+
+    return externalPackageNotice(resolution);
+};
+
+const externalPackageNotices = (link: StoreLink): string[] => {
+    const notices: string[] = [];
+
+    for (const entry of EXTERNAL_NAMESPACES) {
+        const notice = entryNotice(link, entry);
+
+        if (notice !== undefined) {
+            notices.push(notice);
+        }
+    }
+
+    return notices;
+};
+
+export { ensureExternalPackageLinks, externalPackageNotices, resetExternalPackageLinks };

package/src/store/gi/callable-doc.ts

@@ -12,7 +12,7 @@ import {
 } from "../../analysis/param-structure.js";
 import { renderJsDoc } from "../../writer/doc.js";
 import { annotationSpec, THROWS_TEXT } from "./doc-spec.js";
-import { isCallbackParameter, returnedOutParameters } from "./method.js";
+import { isCallbackParameter, returnedOutParameters, shouldTrimFinishBoolean } from "./method.js";
 
 type CallableDocOptions = {
     finishFn?: GirFunction | undefined;
@@ -53,9 +53,9 @@ const tupleReturnsText = (primary: string | undefined, outs: InputParameter[]):
     return bullets.length === 0 ? undefined : `Tuple of:\n\n${bullets.join("\n")}`;
 };
 
-const returnsText = (context: ModuleContext, fn: GirFunction): string | undefined => {
+const returnsText = (context: ModuleContext, fn: GirFunction, isPrimaryTrimmed: boolean): string | undefined => {
     const outs = returnedOutParameters(context, fn);
-    const isPrimaryOmitted = shouldOmitPrimaryReturn(context.library, fn.returnValue);
+    const isPrimaryOmitted = isPrimaryTrimmed || shouldOmitPrimaryReturn(context.library, fn.returnValue);
     const primary = isPrimaryOmitted ? undefined : fn.returnValue.doc;
 
     if (outs.length === 0) {
@@ -92,7 +92,11 @@ const callableSpec = (context: ModuleContext, callable: GirFunction, options: Ca
         (parameter) => options.finishFn !== undefined && isCallbackParameter(context, parameter),
         options.renames,
     ),
-    returns: returnsText(context, options.finishFn ?? callable),
+    returns: returnsText(
+        context,
+        options.finishFn ?? callable,
+        options.finishFn !== undefined && shouldTrimFinishBoolean(context, options.finishFn),
+    ),
     throws: canCallableThrow(callable, options.finishFn) ? THROWS_TEXT : undefined,
 });
 

package/src/store/gi/callables.ts

@@ -7,7 +7,7 @@ import { renderBlock } from "../../writer/emit.js";
 import { matchAsyncFinish } from "./async.js";
 import { callableDoc, callableSpec } from "./callable-doc.js";
 import { renderFnExpression } from "./function.js";
-import { gtypeMemberDeclaration, gtypeStaticMember } from "./gtype-binding.js";
+import { gtypeMemberDeclaration } from "./gtype-binding.js";
 import {
     finishCallExpression,
     memberName,
@@ -66,7 +66,7 @@ type PlainTypeMembersOptions = {
     context: ModuleContext;
     className: string;
     callables: Callables;
-    gtypeExpr: string | undefined;
+    hasGtype: boolean;
 };
 
 const RUNTIME_OWNED_LIFETIME_METHODS: Set<string> = new Set([
@@ -358,7 +358,7 @@ const renderPromisifiedCallable = (
     const body = renderPromisifiedBody(
         context,
         callable,
-        finishCallExpression(callable, finishFn, member.ownerName),
+        { fn: finishFn, expression: finishCallExpression(callable, finishFn, member.ownerName) },
         toCamelIdentifier(cIdentifier),
     );
 
@@ -514,11 +514,11 @@ const renderPlainInstanceMethods = (
 const renderPlainTypeMembers = (
     options: PlainTypeMembersOptions,
 ): { members: string[]; claimedNames: Set<string> } => {
-    const { context, className, callables, gtypeExpr } = options;
+    const { context, className, callables, hasGtype } = options;
     const claimedNames: Set<string> = new Set();
 
     const members: string[] = [
-        ...(gtypeExpr === undefined ? [] : [gtypeMemberDeclaration(context), gtypeStaticMember(context)]),
+        ...(hasGtype ? [gtypeMemberDeclaration(context)] : []),
         ...renderStaticHead(context, callables, className),
         ...renderPlainInstanceMethods(context, callables.methods, claimedNames),
     ];

package/src/store/gi/class.ts

@@ -34,7 +34,7 @@ import {
 } from "./callables.js";
 import { renderClassConstructor, renderConstructorPropsInterface } from "./constructor-props.js";
 import { getDoc } from "./doc-spec.js";
-import { gtypeMemberDeclaration, gtypeStaticMember, renderSourceGtype } from "./gtype-binding.js";
+import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import { renderPropertyDeclarations } from "./properties.js";
 import { renderResolvedPropertyAccessor, resolveAccessor, type ResolvedAccessor } from "./property-accessor.js";
@@ -60,14 +60,6 @@ type MemberDeclarationsOptions = {
 
 type ClassMembers = { members: string[]; accessors: ResolvedAccessor[] };
 
-type ClassMembersOptions = {
-    context: ModuleContext;
-    klass: GirClass;
-    callables: Callables;
-    gtypeExpr: string | undefined;
-    hasParent: boolean;
-};
-
 type ImplementedRefOptions = {
     context: ModuleContext;
     klass: GirClass;
@@ -105,16 +97,7 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
     const implemented = resolveImplementedRefs(context, klass);
     const typeRefs = implemented.map((ref) => omittedTypeRef(ref.typeRef, ref.conflicts));
     const implementsClause = typeRefs.length === 0 ? "" : ` implements ${typeRefs.join(", ")}`;
-    const gtypeExpr = renderSourceGtype(context, klass);
-
-    const { members, accessors } = renderClassMembers({
-        context,
-        klass,
-        callables,
-        gtypeExpr,
-        hasParent: parentExpression !== undefined,
-    });
-
+    const { members, accessors } = renderClassMembers(context, klass, callables, parentExpression !== undefined);
     const body = indentMembers(members);
     const doc = getDoc(klass);
     const modifier = klass.isAbstract ? "abstract " : "";
@@ -132,7 +115,7 @@ const generateClass = (context: ModuleContext, klass: GirClass): void => {
 
     appendMemberDeclarations({ context, klass, className, accessors, implemented });
     appendInstallMixins(context, className, implemented);
-    appendClassRegistrations(context, klass, className, gtypeExpr);
+    appendClassRegistrations(context, klass, className);
 };
 
 const appendMemberDeclarations = (options: MemberDeclarationsOptions): void => {
@@ -167,14 +150,15 @@ const appendInterfaceMerge = (
     });
 };
 
-const renderClassMembers = (options: ClassMembersOptions): ClassMembers => {
-    const { context, klass, callables, gtypeExpr } = options;
+const renderClassMembers = (
+    context: ModuleContext,
+    klass: GirClass,
+    callables: Callables,
+    hasParent: boolean,
+): ClassMembers => {
     const className = sanitizeTypeIdentifier(klass.name);
-
-    const members: string[] =
-        gtypeExpr === undefined ? [] : [gtypeMemberDeclaration(context), gtypeStaticMember(context)];
-
-    const constructorBlock = renderClassConstructor(context, klass, className, options.hasParent);
+    const members: string[] = [gtypeMemberDeclaration(context)];
+    const constructorBlock = renderClassConstructor(context, klass, className, hasParent);
 
     if (constructorBlock !== undefined) {
         members.push(constructorBlock);
@@ -255,17 +239,43 @@ const appendInstallMixins = (context: ModuleContext, className: string, implemen
     ]);
 };
 
-const appendClassRegistrations = (
+const appendClassRegistrations = (context: ModuleContext, klass: GirClass, className: string): void => {
+    const gtypeExpr = renderSourceGtype(context, klass);
+
+    appendWrapperClassRegistration(context, {
+        className,
+        gtypeExpr,
+        vfuncs: renderVfuncMetadata(context, klass),
+    });
+
+    appendClassStructRegistration(context, klass, className, gtypeExpr);
+};
+
+const appendClassStructRegistration = (
     context: ModuleContext,
     klass: GirClass,
     className: string,
     gtypeExpr: string | undefined,
 ): void => {
-    appendWrapperClassRegistration(context, {
+    const typeStruct = klass.glibTypeStruct;
+
+    if (gtypeExpr === undefined || typeStruct === undefined) {
+        return;
+    }
+
+    const resolved = context.library.resolveType(context.namespace.name, typeStruct);
+
+    if (resolved?.kind !== "record" || !isEmittableEntity(resolved.value)) {
+        return;
+    }
+
+    const structName = sanitizeTypeIdentifier(resolved.value.name);
+    context.addRuntimeImport("registerClassStruct");
+
+    context.module.appendRegistration(`registerClassStruct(${className}, ${structName});`, [
         className,
-        gtypeExpr,
-        vfuncs: renderVfuncMetadata(context, klass),
-    });
+        structName,
+    ]);
 };
 
 const addAncestorInterfaceKeys = (context: ModuleContext, ancestor: ResolvedAncestor, keys: Set<string>): void => {

package/src/store/gi/constructor-props.ts

@@ -76,7 +76,7 @@ const renderRootConstructor = (context: ModuleContext): string => {
     context.addRuntimeTypeImport("AnyClass");
     context.addRuntimeImport("getClassType");
     context.addRuntimeImport("newObjectWithProperties");
-    const body = "newObjectWithProperties(getClassType(this.constructor as AnyClass), props, this);";
+    const body = "return newObjectWithProperties(getClassType(this.constructor as AnyClass), props, this);";
 
     return renderBlock("constructor(props: object = {})", body);
 };

package/src/store/gi/function.ts

@@ -48,6 +48,7 @@ const renderFnExpression = (context: ModuleContext, fn: GirFunction): string | u
         args: arrayLiteral(params),
         returns: returnPlan.descriptor,
         isReturnSkipped: returnPlan.isSkipped,
+        isReturnUnpacked: returnPlan.isUnpacked,
         canThrow: fn.throws,
     });
 };
@@ -132,7 +133,7 @@ const matchNamespaceFinish = (context: ModuleContext, fn: GirFunction): Namespac
 const renderPromisifiedNamespaceFunction = (options: NamespaceFunctionOptions, finish: NamespaceFinish): string => {
     const { context, fn, exportName, bindingName } = options;
     const { signature, returnType } = renderPromisifiedSignature(context, fn, finish.fn);
-    const body = renderPromisifiedBody(context, fn, finish.exportName, bindingName);
+    const body = renderPromisifiedBody(context, fn, { fn: finish.fn, expression: finish.exportName }, bindingName);
 
     return renderBlock(`export function ${exportName}(${signature}): ${returnType}`, body);
 };

package/src/store/gi/gtype-binding.ts

@@ -1,32 +1,24 @@
 import { sourceStringLiteral } from "@gtkx/utils";
 import type { ModuleContext } from "../../writer/context.js";
 import { PRIMITIVE_TS_TYPE } from "../../gir/primitives.js";
-import { renderJsDoc } from "../../writer/doc.js";
-import { renderBlock } from "../../writer/emit.js";
 
 type TypeSource = {
     glibGetType: string | undefined;
     glibTypeName: string | undefined;
 };
 
-const GTYPE_NOTE = [
-    "The GType this class is registered under, read off the class it is accessed on rather than",
-    "inherited, so a subclass `registerClass` created reports its own type and one that never went",
-    "through `registerClass` reports the invalid type.",
-].join("\n");
-
 const gtypeTsType = (context: ModuleContext): string =>
     context.namespace.name === "GObject" ? "Type" : PRIMITIVE_TS_TYPE.gtype;
 
-const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
-
-const gtypeStaticMember = (context: ModuleContext): string => {
-    context.addRuntimeImport("getClassType");
-    const block = renderBlock(`static get __gtype__(): ${gtypeTsType(context)}`, "return getClassType(this);");
+const gtypeParamTsType = (context: ModuleContext): string => {
+    context.addRuntimeTypeImport("AnyClass");
+    context.addRuntimeTypeImport("TypedClass");
 
-    return `${renderJsDoc(undefined, GTYPE_NOTE)}${block}`;
+    return `${gtypeTsType(context)} | AnyClass<TypedClass>`;
 };
 
+const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
+
 const renderInternGtype = (context: ModuleContext, typeName: string | undefined): string | undefined => {
     if (typeName === undefined) {
         return undefined;
@@ -63,4 +55,4 @@ const renderSourceGtype = (context: ModuleContext, source: TypeSource): string |
         ? undefined
         : renderGtypeExpression(context, source.glibGetType, source.glibTypeName);
 
-export { gtypeTsType, gtypeMemberDeclaration, gtypeStaticMember, renderSourceGtype };
+export { gtypeTsType, gtypeParamTsType, gtypeMemberDeclaration, renderSourceGtype };

package/src/store/gi/interface.ts

@@ -21,7 +21,7 @@ import {
     renderStaticHead,
 } from "./callables.js";
 import { annotationSpec, getDoc } from "./doc-spec.js";
-import { gtypeStaticMember, renderSourceGtype } from "./gtype-binding.js";
+import { gtypeMemberDeclaration, renderSourceGtype } from "./gtype-binding.js";
 import { methodExportName } from "./method.js";
 import {
     type PropertyAccessorArgs,
@@ -378,7 +378,7 @@ const renderInterfaceClass = (context: ModuleContext, options: InterfaceClassOpt
     const members: string[] = [];
 
     if (gtypeExpr !== undefined) {
-        members.push(renderInterfaceHasInstance(context, className, gtypeExpr), gtypeStaticMember(context));
+        members.push(gtypeMemberDeclaration(context), renderInterfaceHasInstance(context, className, gtypeExpr));
     }
 
     members.push(...renderStaticHead(context, callables, className), renderInterfaceBrand(context, implRef));