@gtkx/codegen 1.2.2 → 1.4.0

package/src/store/gi/vtable.ts

@@ -11,6 +11,7 @@ import type { JsDocSpec } from "../../writer/doc.js";
 import {
     isInlineCallbackRef,
     isScalarRef,
+    renderCallbackType,
     renderDescriptor,
     renderParamDescriptor,
 } from "../../analysis/descriptor-render.js";
@@ -19,7 +20,6 @@ import {
     handlerParameters,
     parameterIdentifier,
     renamesWithInstance,
-    renderHandlerParameters,
     renderHandlerResultType,
 } from "../../analysis/param-structure.js";
 import { renderTsType } from "../../analysis/ts-type.js";
@@ -74,6 +74,12 @@ type Vtable = {
     slots: VtableSlot[];
 };
 
+type SlotParamPlan = {
+    parameters: GirParameter[];
+    argIndexMap: Map<number, number>;
+    decoded: Set<GirParameter>;
+};
+
 const PADDING_FIELD_NAME = /^(?:reserved|padding)\d*$/i;
 
 const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
@@ -86,6 +92,7 @@ const UNCALLABLE_SLOT_KEYS: Set<string> = new Set([
 const VTABLE_CACHE: WeakMap<GirClass, Vtable> = new WeakMap();
 const PROTECTED_SLOT_NOTE = "It is `protected`, so only a subclass chaining up reaches it.";
 const PUBLIC_SLOT_NOTE = "Calling it from anywhere else re-enters the slot on a live instance.";
+const OPAQUE_CALLBACK_NOTE = "Received as the raw address of the C function pointer.";
 
 const vfuncMemberName = (fieldName: string): string => `vfunc${pascalCase(fieldName)}`;
 
@@ -125,6 +132,79 @@ const vtableCallbackType = (context: ModuleContext, field: GirField): GirCallbac
     return type.value;
 };
 
+const isCallbackParam = (context: ModuleContext, parameter: GirParameter): boolean =>
+    parameter.type !== undefined && context.library.typeFor(parameter.type)?.kind === "callback";
+
+const isDecodedCallbackParam = (context: ModuleContext, parameter: GirParameter, index: number): boolean =>
+    isCallbackParam(context, parameter) &&
+    parameter.closureIndex === index + 1 &&
+    parameter.destroyIndex === undefined;
+
+const decodedSlotParams = (context: ModuleContext, callback: GirCallback): Set<GirParameter> => {
+    const decoded: Set<GirParameter> = new Set();
+
+    for (const [index, parameter] of callback.parameters.entries()) {
+        if (isDecodedCallbackParam(context, parameter, index)) {
+            decoded.add(parameter);
+        }
+    }
+
+    return decoded;
+};
+
+const companionIndices = (decoded: Set<GirParameter>): Set<number> => {
+    const companions: Set<number> = new Set();
+
+    for (const parameter of decoded) {
+        if (parameter.closureIndex !== undefined) {
+            companions.add(parameter.closureIndex);
+        }
+    }
+
+    return companions;
+};
+
+const slotParamPlan = (context: ModuleContext, callback: GirCallback): SlotParamPlan => {
+    const decoded = decodedSlotParams(context, callback);
+    const companions = companionIndices(decoded);
+    const parameters: GirParameter[] = [];
+    const argIndexMap: Map<number, number> = new Map();
+
+    for (const [index, parameter] of callback.parameters.entries()) {
+        if (companions.has(index)) {
+            continue;
+        }
+
+        argIndexMap.set(index, parameters.length);
+        parameters.push(parameter);
+    }
+
+    return { parameters, argIndexMap, decoded };
+};
+
+const isOpaqueCallbackParam = (context: ModuleContext, plan: SlotParamPlan, parameter: GirParameter): boolean =>
+    isCallbackParam(context, parameter) && !plan.decoded.has(parameter);
+
+const renderSlotParamDescriptor = (context: ModuleContext, parameter: GirParameter, plan: SlotParamPlan): string => {
+    if (plan.decoded.has(parameter)) {
+        const callbackDescriptor = renderCallbackType(context, parameter.type, parameter);
+
+        if (callbackDescriptor !== undefined) {
+            return callbackDescriptor;
+        }
+    }
+
+    return renderParamDescriptor(context, parameter, parameter.type, { argIndexMap: plan.argIndexMap });
+};
+
+const renderSlotParamTsType = (context: ModuleContext, plan: SlotParamPlan, parameter: GirParameter): string => {
+    if (isOpaqueCallbackParam(context, plan, parameter)) {
+        return parameter.nullable ? "bigint | null" : "bigint";
+    }
+
+    return renderTsType(context, parameter.type, parameter.nullable);
+};
+
 const vtableSlotEntry = (
     context: ModuleContext,
     field: GirField,
@@ -387,15 +467,35 @@ const hasCallableVfuncSlots = (context: ModuleContext, namespaceName: string, kl
 
 const slotDoc = (slot: VtableSlot): string | undefined => slot.vfunc?.doc ?? slot.field.doc ?? slot.callback.doc;
 
-const slotDocParameters = (slot: VtableSlot): GirParameter[] => {
+const slotParamDoc = (
+    context: ModuleContext,
+    plan: SlotParamPlan,
+    parameter: GirParameter,
+    doc: string | undefined,
+): string | undefined => {
+    if (!isOpaqueCallbackParam(context, plan, parameter)) {
+        return doc;
+    }
+
+    return doc === undefined ? OPAQUE_CALLBACK_NOTE : `${doc} ${OPAQUE_CALLBACK_NOTE}`;
+};
+
+const slotDocParameters = (context: ModuleContext, slot: VtableSlot): GirParameter[] => {
+    const plan = slotParamPlan(context, slot.callback);
     const [, ...parameters] = slot.callback.parameters;
     const vfuncParameters = slot.vfunc?.parameters ?? [];
 
-    return parameters.map((parameter, index) => ({ ...parameter, doc: vfuncParameters[index]?.doc ?? parameter.doc }));
+    return parameters
+        .map((parameter, index) => ({ parameter, index }))
+        .filter(({ index }) => plan.argIndexMap.has(index + 1))
+        .map(({ parameter, index }) => ({
+            ...parameter,
+            doc: slotParamDoc(context, plan, parameter, vfuncParameters[index]?.doc ?? parameter.doc),
+        }));
 };
 
-const slotDocSpec = (slot: VtableSlot): JsDocSpec => {
-    const parameters = slotDocParameters(slot);
+const slotDocSpec = (context: ModuleContext, slot: VtableSlot): JsDocSpec => {
+    const parameters = slotDocParameters(context, slot);
     const source = slot.vfunc ?? slot.callback;
 
     return {
@@ -446,12 +546,18 @@ const isCallableSlot = (context: ModuleContext, slot: VtableSlot): boolean =>
     !UNCALLABLE_SLOT_KEYS.has(slot.key) && !hasUnannotatedPointerParam(context, slot);
 
 const vfuncSlotSignature = (context: ModuleContext, slot: VtableSlot, isOptional = false): VfuncSignature => {
-    const [, ...parameters] = slot.callback.parameters;
+    const plan = slotParamPlan(context, slot.callback);
+    const [, ...parameters] = plan.parameters;
 
     const renderType = (ref: TypeId | undefined, isNullable: boolean): string =>
         renderTsType(context, ref, isNullable);
 
-    const signature = renderHandlerParameters(parameters, renderType).join(", ");
+    const signature = handlerParameters(parameters)
+        .map(
+            (parameter, index) =>
+                `${parameterIdentifier(parameter, index)}: ${renderSlotParamTsType(context, plan, parameter)}`)
+        .join(", ");
+
     const folded = foldedLengthParameters(context.library, slot.callback);
 
     const returnType = renderHandlerResultType({
@@ -470,13 +576,13 @@ const renderVfuncMember = (options: VfuncMemberOptions): string => {
     const { context, ownerRef, slot, mode, isProtected } = options;
     const { header, returnType } = vfuncSlotSignature(context, slot, mode === "requirement");
     const declaration = `${isProtected ? "protected " : ""}${header}`;
-    const doc = renderJsDoc(slotDoc(slot), vfuncMemberNote(options), slotDocSpec(slot));
+    const doc = renderJsDoc(slotDoc(slot), vfuncMemberNote(options), slotDocSpec(context, slot));
 
     if (mode !== "implementation") {
         return `${doc}${declaration};`;
     }
 
-    const [, ...parameters] = slot.callback.parameters;
+    const [, ...parameters] = slotParamPlan(context, slot.callback).parameters;
 
     const inputs = handlerParameters(parameters).map((parameter, index) =>
         parameterIdentifier(parameter, index));
@@ -511,9 +617,10 @@ const isVtableSlotEligible = (context: ModuleContext, callback: GirCallback): bo
 
 const renderVtableSlotDescriptor = (context: ModuleContext, vtable: Vtable, slot: VtableSlot): string => {
     const { key, field, callback, byteOffset } = slot;
+    const plan = slotParamPlan(context, callback);
 
-    const argDescriptors = callback.parameters
-        .map((param) => renderParamDescriptor(context, param, param.type))
+    const argDescriptors = plan.parameters
+        .map((param) => renderSlotParamDescriptor(context, param, plan))
         .join(", ");
 
     const returnDescriptor = renderDescriptor(

package/src/store/gi-store.ts

@@ -1,8 +1,14 @@
+import { sortStrings } from "@gtkx/utils";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { SourceModule } from "../compile.js";
 import { FINGERPRINT_FILENAME, type GiFingerprint } from "../fingerprint.js";
+import {
+    type GeneratedLibraries,
+    LIBRARIES_FILENAME,
+    renderGeneratedLibraries,
+} from "./gi/generated-libraries.js";
 import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
 type GiNamespaceInput = {
@@ -11,6 +17,17 @@ type GiNamespaceInput = {
     girFile: string;
 };
 
+type GiExternalNamespaceInput = {
+    directory: string;
+    packageName: string;
+    girFile: string;
+};
+
+type GiStoreRecords = {
+    fingerprint: GiFingerprint;
+    libraries: GeneratedLibraries;
+};
+
 const OVERRIDES_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "overrides");
 
 const overrideFiles = (directory: string): SourceModule[] => {
@@ -42,8 +59,17 @@ const barrelFile = (directory: string, girFile: string): SourceModule => {
     return overrideModule(barrel.fileName, overrideIndex);
 };
 
+const externalShimModule = ({ directory, packageName, girFile }: GiExternalNamespaceInput): SourceModule => ({
+    fileName: `${directory}/index.ts`,
+    source:
+        `/** @deprecated Import from "${packageName}" instead; this alias is removed in GTKX 2.0. */\n` +
+        `export * from "${packageName}";\n`,
+    origin: girFile,
+});
+
 const collectStoreSources = (
     namespaces: GiNamespaceInput[],
+    externalNamespaces: GiExternalNamespaceInput[],
 ): { collected: SourceModule[]; exportsMap: Record<string, unknown> } => {
     const exportsMap: Record<string, unknown> = {};
     const collected: SourceModule[] = [];
@@ -58,15 +84,29 @@ const collectStoreSources = (
         exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
     }
 
+    for (const external of externalNamespaces) {
+        collected.push(externalShimModule(external));
+        exportsMap[`./${external.directory}`] = subpathExport(`${external.directory}/index`);
+    }
+
     return { collected, exportsMap };
 };
 
+const storePeerDependencies = (externalNamespaces: GiExternalNamespaceInput[]): Record<string, string> =>
+    Object.fromEntries(
+        sortStrings(["@gtkx/runtime", ...externalNamespaces.map((entry) => entry.packageName)]).map((name) => [
+            name,
+            "*",
+        ]),
+    );
+
 const writeGiStore = (
     options: StoreOptions,
     namespaces: GiNamespaceInput[],
-    fingerprint: GiFingerprint,
+    externalNamespaces: GiExternalNamespaceInput[],
+    records: GiStoreRecords,
 ): void => {
-    const { collected, exportsMap } = collectStoreSources(namespaces);
+    const { collected, exportsMap } = collectStoreSources(namespaces, externalNamespaces);
 
     writeStore({
         storeDir: options.storeDir,
@@ -76,10 +116,13 @@ const writeGiStore = (
             name: "@gtkx/gi",
             version: options.version,
             exports: exportsMap,
-            peerDependencies: { "@gtkx/runtime": "*" },
+            peerDependencies: storePeerDependencies(externalNamespaces),
         }),
-        rawFiles: [{ relativePath: FINGERPRINT_FILENAME, content: `${JSON.stringify(fingerprint, null, 2)}\n` }],
+        rawFiles: [
+            { relativePath: FINGERPRINT_FILENAME, content: `${JSON.stringify(records.fingerprint, null, 2)}\n` },
+            { relativePath: LIBRARIES_FILENAME, content: renderGeneratedLibraries(records.libraries) },
+        ],
     });
 };
 
-export { writeGiStore, type GiNamespaceInput };
+export { writeGiStore, type GiExternalNamespaceInput, type GiNamespaceInput };

package/src/store/jsx/jsx.ts

@@ -3,6 +3,7 @@ import type { GirClass } from "../../gir/class.js";
 import type { Library } from "../../gir/library.js";
 import type { GirNamespace } from "../../gir/namespace.js";
 import type { ImportsBuilder } from "../../writer/imports.js";
+import { externalPackageFor } from "../../gir/external-namespaces.js";
 import { renderBlock } from "../../writer/emit.js";
 import { getDoc } from "../gi/doc-spec.js";
 import { elementPropTypeFor } from "./element-prop-imports.js";
@@ -48,7 +49,8 @@ const addGiNamespace = (imports: ImportsBuilder, namespaceName: string, alias: s
         return;
     }
 
-    imports.addNamespace(`@gtkx/gi/${namespaceName.toLowerCase()}`, alias, true);
+    const specifier = externalPackageFor(namespaceName) ?? `@gtkx/gi/${namespaceName.toLowerCase()}`;
+    imports.addNamespace(specifier, alias, true);
 };
 
 const addReactBuiltin = (imports: ImportsBuilder, name: string): void => {

package/src/store/jsx/metadata.ts

@@ -17,22 +17,17 @@ import {
 type IntrinsicElementEntry = {
     glibName: string;
     signals: [string, string][];
-    constructOnly: string[];
-    constructable: string[];
-    defaults: [string, string][];
+    properties: [string, string][];
 };
 
-type PropNameCollector = {
-    shouldKeep: (property: GirProperty) => boolean;
-    seen: Set<string>;
-    names: string[];
-};
+const READABLE = 1;
+const WRITABLE = 2;
+const CONSTRUCT = 4;
+const CONSTRUCT_ONLY = 8;
 
-type DefaultPropsCollector = {
-    library: Library;
-    seen: Set<string>;
-    defaults: [string, string][];
-};
+const PROPERTY_ENTRY_TYPE =
+    "/** The GObject name of a property, what a write may do to it, and the value it resets to. */\n" +
+    "export type PropertyEntry = [name: string, flags: number, defaultValue?: unknown];";
 
 const INTEGER_PATTERN = /^-?\d+$/;
 const FLOAT_PATTERN = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i;
@@ -44,23 +39,15 @@ const generateMetadata = (library: Library): string => {
         ({ glibName, signals }) => `    "${glibName}": ${renderSignalsObject(signals)},`,
     );
 
-    const constructOnlyEntries = intrinsicElements
-        .filter(({ constructOnly }) => constructOnly.length > 0)
-        .map(({ glibName, constructOnly }) => `    "${glibName}": ${renderStringSet(constructOnly)},`);
-
-    const constructableEntries = intrinsicElements
-        .filter(({ constructable }) => constructable.length > 0)
-        .map(({ glibName, constructable }) => `    "${glibName}": ${renderStringSet(constructable)},`);
-
-    const defaultsEntries = intrinsicElements
-        .filter(({ defaults }) => defaults.length > 0)
-        .map(({ glibName, defaults }) => `    "${glibName}": ${renderDefaultsObject(defaults)},`);
+    const propertyEntries = intrinsicElements
+        .filter(({ properties }) => properties.length > 0)
+        .map(({ glibName, properties }) => `    "${glibName}": ${renderPropertiesObject(properties)},`);
 
     return `${[
+        PROPERTY_ENTRY_TYPE,
         `export const signals: Record<string, Record<string, string>> = {\n${signalsEntries.join("\n")}\n};`,
-        `export const constructOnlyProps: Record<string, Set<string>> = {\n${constructOnlyEntries.join("\n")}\n};`,
-        `export const constructProps: Record<string, Set<string>> = {\n${constructableEntries.join("\n")}\n};`,
-        `export const defaultProps: Record<string, Record<string, unknown>> = {\n${defaultsEntries.join("\n")}\n};`,
+        "export const properties: Record<string, Record<string, PropertyEntry>> = " +
+        `{\n${propertyEntries.join("\n")}\n};`,
     ].join("\n\n")}\n`;
 };
 
@@ -83,9 +70,7 @@ const collectIntrinsicElements = (library: Library): IntrinsicElementEntry[] =>
         entries.push({
             glibName,
             signals: collectSignals(sources),
-            constructOnly: collectConstructOnly(sources),
-            constructable: collectConstructable(sources),
-            defaults: collectDefaultProps(library, sources),
+            properties: collectProperties(library, sources),
         });
     }
 
@@ -116,41 +101,52 @@ const collectSignals = (sources: GirClass[]): [string, string][] => {
     return signals;
 };
 
-const collectPropNamesFromSource = (source: GirClass, collector: PropNameCollector): void => {
-    const { shouldKeep, seen, names } = collector;
+const propertyFlags = (property: GirProperty): number => {
+    const construct = isConstructableProperty(property) && !property.constructOnly ? CONSTRUCT : 0;
+    const constructOnly = property.constructOnly ? CONSTRUCT_ONLY : 0;
 
-    for (const property of source.properties) {
-        if (!shouldKeep(property)) {
-            continue;
-        }
+    return (property.readable ? READABLE : 0) |
+        (property.writable ? WRITABLE : 0) |
+        construct |
+        constructOnly;
+};
+
+const propertyEntryLiteral = (library: Library, klass: GirClass, property: GirProperty): string => {
+    const head = `${sourceStringLiteral(property.name)},${String(propertyFlags(property))}`;
+    const literal = isDefaultCandidate(property) ? renderDefaultLiteral(library, klass, property) : undefined;
+
+    return literal === undefined ? `[${head}]` : `[${head},${literal}]`;
+};
 
+const collectPropertiesFromSource = (
+    library: Library,
+    source: GirClass,
+    seen: Set<string>,
+    entries: [string, string][],
+): void => {
+    for (const property of source.properties) {
         const jsName = toCamelIdentifier(property.name);
 
-        if (seen.has(jsName)) {
+        if (!property.introspectable || seen.has(jsName)) {
             continue;
         }
 
         seen.add(jsName);
-        names.push(jsName);
+        entries.push([jsName, propertyEntryLiteral(library, source, property)]);
     }
 };
 
-const collectPropNames = (sources: GirClass[], shouldKeep: (property: GirProperty) => boolean): string[] => {
-    const collector: PropNameCollector = { shouldKeep, seen: new Set<string>(), names: [] };
+const collectProperties = (library: Library, sources: GirClass[]): [string, string][] => {
+    const seen: Set<string> = new Set();
+    const entries: [string, string][] = [];
 
     for (const source of sources) {
-        collectPropNamesFromSource(source, collector);
+        collectPropertiesFromSource(library, source, seen, entries);
     }
 
-    return collector.names;
+    return entries;
 };
 
-const collectConstructOnly = (sources: GirClass[]): string[] =>
-    collectPropNames(sources, (property) => property.constructOnly && property.introspectable);
-
-const collectConstructable = (sources: GirClass[]): string[] =>
-    collectPropNames(sources, (property) => isConstructableProperty(property) && property.introspectable);
-
 const renderObjectLiteral = (entries: [string, string][], renderValue: (value: string) => string): string => {
     if (entries.length === 0) {
         return "{}";
@@ -161,60 +157,14 @@ const renderObjectLiteral = (entries: [string, string][], renderValue: (value: s
     return `{\n${lines.join(",\n")}\n    }`;
 };
 
-const renderStringSet = (names: string[]): string =>
-    `new Set([${names.map((name) => sourceStringLiteral(name)).join(",")}])`;
+const renderPropertiesObject = (entries: [string, string][]): string =>
+    renderObjectLiteral(entries, (value) => value);
 
 const renderSignalsObject = (entries: [string, string][]): string => renderObjectLiteral(entries, sourceStringLiteral);
 
-const collectDefaultsFromClass = (klass: GirClass, collector: DefaultPropsCollector): void => {
-    for (const property of klass.properties) {
-        const entry = defaultPropEntry(collector.library, klass, property, collector.seen);
-
-        if (entry !== undefined) {
-            collector.defaults.push(entry);
-        }
-    }
-};
-
-const collectDefaultProps = (library: Library, sources: GirClass[]): [string, string][] => {
-    const collector: DefaultPropsCollector = { library, seen: new Set<string>(), defaults: [] };
-
-    for (const klass of sources) {
-        collectDefaultsFromClass(klass, collector);
-    }
-
-    return collector.defaults;
-};
-
 const isDefaultCandidate = (property: GirProperty): boolean =>
     (property.writable || property.construct) && !property.constructOnly && property.introspectable;
 
-const defaultPropEntry = (
-    library: Library,
-    klass: GirClass,
-    property: GirProperty,
-    seen: Set<string>,
-): [string, string] | undefined => {
-    if (!isDefaultCandidate(property)) {
-        return undefined;
-    }
-
-    const jsName = toCamelIdentifier(property.name);
-
-    if (seen.has(jsName)) {
-        return undefined;
-    }
-
-    seen.add(jsName);
-    const literal = renderDefaultLiteral(library, klass, property);
-
-    if (literal === undefined) {
-        return undefined;
-    }
-
-    return [jsName, literal];
-};
-
 const willSetterRejectNull = (library: Library, klass: GirClass, property: GirProperty): boolean => {
     if (property.setter === undefined) {
         return false;
@@ -382,7 +332,4 @@ const enumDefaultLiteral = (enumType: GirEnum, raw: string): string | undefined
     return member?.value;
 };
 
-const renderDefaultsObject = (entries: [string, string][]): string =>
-    renderObjectLiteral(entries, (literal) => literal);
-
 export { generateMetadata };

package/src/store/jsx-store.ts

@@ -1,24 +1,40 @@
+import { sortStrings } from "@gtkx/utils";
 import type { JsxNamespaceFile } from "./jsx/pipeline.js";
 import type { RawFile } from "./store-fs.js";
 import { buildManifest, namespaceBarrel, type StoreOptions, subpathExport, writeStore } from "./store-fs.js";
 
-const writeJsxStore = (
-    options: StoreOptions,
-    namespaces: JsxNamespaceFile[],
-    metadata: string,
-    rawFiles: RawFile[],
-): void => {
+type WriteJsxStoreParams = {
+    options: StoreOptions;
+    namespaces: JsxNamespaceFile[];
+    metadata: string;
+    externalPackages: string[];
+    rawFiles: RawFile[];
+};
+
+const jsxPeerDependencies = (externalPackages: string[]): Record<string, string> =>
+    Object.fromEntries(
+        sortStrings(["@gtkx/gi", "@gtkx/react", "react", ...externalPackages]).map((name) => [name, "*"]),
+    );
+
+const writeJsxStore = (params: WriteJsxStoreParams): void => {
+    const { options, namespaces, metadata, externalPackages, rawFiles } = params;
+
     const exportsMap: Record<string, unknown> = {
+        ".": subpathExport("index"),
         "./metadata": subpathExport("metadata"),
     };
 
     const files = [{ fileName: "metadata.ts", source: metadata }];
+    const indexExports: string[] = [];
 
     for (const { directory, source } of namespaces) {
         files.push({ fileName: `${directory}/${directory}.tsx`, source }, namespaceBarrel(directory));
         exportsMap[`./${directory}`] = subpathExport(`${directory}/index`);
+        indexExports.push(`export * from "./${directory}/index.js";`);
     }
 
+    files.push({ fileName: "index.ts", source: `${indexExports.join("\n")}\n` });
+
     writeStore({
         storeDir: options.storeDir,
         linkDir: options.linkDir,
@@ -27,7 +43,7 @@ const writeJsxStore = (
             name: "@gtkx/jsx",
             version: options.version,
             exports: exportsMap,
-            peerDependencies: { "@gtkx/gi": "*", "@gtkx/react": "*", react: "*" },
+            peerDependencies: jsxPeerDependencies(externalPackages),
         }),
         rawFiles,
     });

package/src/store/resolve-store.ts

@@ -24,9 +24,11 @@ const SCOPE = "@gtkx";
 const STORE_NAMES: string[] = ["gi", "jsx"];
 
 const STORE_CONSUMERS: string[] = [
+    "@gtkx/animated",
     "@gtkx/cli",
     "@gtkx/components",
     "@gtkx/css",
+    "@gtkx/navigation",
     "@gtkx/react",
     "@gtkx/runtime",
     "@gtkx/testing",
@@ -213,4 +215,4 @@ const resolveStore = (projectRoot: string): ResolvedStore => {
     };
 };
 
-export { getShadowingStorePaths, resolveStore, sweepProjectStaging, type ResolvedStore };
+export { getShadowingStorePaths, nodeModulesChain, resolveStore, sweepProjectStaging, type ResolvedStore };

package/src/store/store-fs.ts

@@ -13,6 +13,7 @@ import { dirname, join, relative } from "node:path";
 import { keepFailedProject, type SourceModule } from "../compile.js";
 import { createStagingDir } from "../staging.js";
 import { compileStore } from "./compile-store.js";
+import { ensureExternalPackageLinks, resetExternalPackageLinks } from "./external-package-links.js";
 
 /** Where one generated store is written and how it is reached. */
 type StoreOptions = {
@@ -88,6 +89,7 @@ const writeStore = (params: WriteStoreParams): void => {
     try {
         buildTempStore(tmp, params);
         swapStore(tmp, params.storeDir);
+        resetExternalPackageLinks(params.storeDir);
         ensureStoreLink(params);
     } catch (error) {
         throw keepFailedProject({ projectDir: tmp, keepAt, error });
@@ -148,11 +150,15 @@ const isStoreLinked = (link: StoreLink): boolean => {
 };
 
 const ensureStoreLink = (link: StoreLink): void => {
-    if (!existsSync(join(link.storeDir, "package.json")) || isStoreLinked(link)) {
+    if (!existsSync(join(link.storeDir, "package.json"))) {
         return;
     }
 
-    symlinkRelative(link.linkDir, link.storeDir);
+    if (!isStoreLinked(link)) {
+        symlinkRelative(link.linkDir, link.storeDir);
+    }
+
+    ensureExternalPackageLinks(link);
 };
 
 const storeWriteMessage = (storeDir: string, error: unknown): string =>
@@ -176,7 +182,9 @@ export {
     buildManifest,
     ensureStoreLink,
     namespaceBarrel,
+    symlinkRelative,
     writeStore,
+    type StoreLink,
     type StoreOptions,
     type RawFile,
 };