@gtkx/codegen 1.2.2 → 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

@@ -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),
     );
 

package/src/store/gi/class.ts

@@ -247,6 +247,35 @@ const appendClassRegistrations = (context: ModuleContext, klass: GirClass, class
         gtypeExpr,
         vfuncs: renderVfuncMetadata(context, klass),
     });
+
+    appendClassStructRegistration(context, klass, className, gtypeExpr);
+};
+
+const appendClassStructRegistration = (
+    context: ModuleContext,
+    klass: GirClass,
+    className: string,
+    gtypeExpr: string | undefined,
+): void => {
+    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,
+        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

@@ -10,6 +10,13 @@ type TypeSource = {
 const gtypeTsType = (context: ModuleContext): string =>
     context.namespace.name === "GObject" ? "Type" : PRIMITIVE_TS_TYPE.gtype;
 
+const gtypeParamTsType = (context: ModuleContext): string => {
+    context.addRuntimeTypeImport("AnyClass");
+    context.addRuntimeTypeImport("TypedClass");
+
+    return `${gtypeTsType(context)} | AnyClass<TypedClass>`;
+};
+
 const gtypeMemberDeclaration = (context: ModuleContext): string => `declare __type__: ${gtypeTsType(context)};`;
 
 const renderInternGtype = (context: ModuleContext, typeName: string | undefined): string | undefined => {
@@ -48,4 +55,4 @@ const renderSourceGtype = (context: ModuleContext, source: TypeSource): string |
         ? undefined
         : renderGtypeExpression(context, source.glibGetType, source.glibTypeName);
 
-export { gtypeTsType, gtypeMemberDeclaration, renderSourceGtype };
+export { gtypeTsType, gtypeParamTsType, gtypeMemberDeclaration, renderSourceGtype };