@gtkx/config 2.0.0-beta.10 → 2.0.0-beta.12

package/src/builtin-elements.ts

@@ -0,0 +1,338 @@
+import type { ElementConfigOptions, ModuleExport } from "./config.ts";
+
+const forTypes = (types: string[], config: ElementConfigOptions): Record<string, ElementConfigOptions> =>
+    Object.fromEntries(types.map((type) => [type, config]));
+
+const internal = (name: string): ModuleExport => ({ module: "@gtkx/react/internal", export: name });
+
+const SINGLE_CHILD_TYPES: string[] = [
+    "AdwBin",
+    "AdwClamp",
+    "AdwNavigationPage",
+    "AdwSplitButton",
+    "AdwStatusPage",
+    "AdwTabOverview",
+    "AdwToastOverlay",
+    "AdwToggle",
+    "GtkAspectFrame",
+    "GtkButton",
+    "GtkCheckButton",
+    "GtkDragIcon",
+    "GtkExpander",
+    "GtkFlowBoxChild",
+    "GtkFrame",
+    "GtkGraphicsOffload",
+    "GtkListBoxRow",
+    "GtkListHeader",
+    "GtkListItem",
+    "GtkMenuButton",
+    "GtkPopover",
+    "GtkPopoverBin",
+    "GtkRevealer",
+    "GtkScrolledWindow",
+    "GtkSearchBar",
+    "GtkTreeExpander",
+    "GtkViewport",
+    "GtkWindowHandle",
+];
+
+const CONTENT_SETTER_TYPES: string[] = ["AdwBottomSheet", "AdwOverlaySplitView"];
+
+/**
+ * Built-in GTK and Adwaita element metadata: base props, component wrappers, omitted properties,
+ * and parent-created objects. Contains no behaviors and can be imported without loading GI bindings.
+ */
+const BUILTIN_ELEMENTS: Record<string, ElementConfigOptions> = {
+    ...forTypes(SINGLE_CHILD_TYPES, {
+        props: internal("ChildrenProps"),
+        omittedProps: ["child"],
+    }),
+    ...forTypes(["GtkHeaderBar", "GtkActionBar"], {
+        props: internal("GtkHeaderBarProps"),
+    }),
+    GtkWindow: {
+        props: internal("ChildrenProps"),
+        component: internal("createWindowComponent"),
+        omittedProps: ["child"],
+    },
+    GtkApplicationWindow: {
+        component: internal("createApplicationWindowComponent"),
+    },
+    GtkLabel: {
+        props: internal("ChildrenProps"),
+    },
+    GtkTextBuffer: {
+        props: internal("ChildrenProps"),
+    },
+    GtkTextTag: {
+        props: internal("ChildrenProps"),
+    },
+    GtkTextChildAnchor: {
+        props: { ...internal("GtkTextChildAnchorProps"), constructOnly: ["replacement"] },
+    },
+    GtkGridLayoutChild: {
+        isLazy: true,
+    },
+    GtkFixedLayoutChild: {
+        isLazy: true,
+    },
+    GtkOverlayLayoutChild: {
+        isLazy: true,
+    },
+    GtkStackPage: {
+        isLazy: true,
+    },
+    GtkNotebookPage: {
+        isLazy: true,
+    },
+    GActionGroup: {
+        props: internal("ActionGroupProps"),
+    },
+    GtkAccessible: {
+        props: { module: "@gtkx/react", export: "AccessibleProps" },
+    },
+    GtkWidget: {
+        props: { ...internal("GtkWidgetProps"), constructOnly: ["textChildAnchor"] },
+    },
+    GtkBox: {
+        props: internal("ChildrenProps"),
+    },
+    GtkListBox: {
+        props: internal("GtkListBoxProps"),
+        component: internal("createListBoxComponent"),
+    },
+    GtkFlowBox: {
+        props: internal("ChildrenProps"),
+    },
+    GtkOverlay: {
+        props: internal("GtkOverlayProps"),
+        omittedProps: ["child"],
+    },
+    GtkShortcutController: {
+        props: internal("GtkShortcutControllerProps"),
+    },
+    GtkCallbackAction: {
+        component: internal("createCallbackActionComponent"),
+        props: {
+            ...internal("GtkCallbackActionElementProps"),
+            composition: "factory",
+            constructOnly: ["callback"],
+        },
+    },
+    GtkCustomLayout: {
+        component: internal("createCustomLayoutComponent"),
+        props: {
+            ...internal("GtkCustomLayoutElementProps"),
+            composition: "factory",
+            constructOnly: ["requestMode", "measure", "allocate"],
+        },
+    },
+    GtkShortcutTrigger: {
+        component: internal("createShortcutTriggerComponent"),
+        props: {
+            ...internal("GtkShortcutTriggerElementProps"),
+            composition: "factory",
+            constructOnly: ["accelerator"],
+        },
+    },
+    GtkTextView: {
+        acceptedChildTypes: ["GtkTextBuffer", "GtkWidget"],
+        props: internal("ChildrenProps"),
+    },
+    GActionMap: {
+        props: internal("ActionMapProps"),
+    },
+    GMenu: {
+        acceptedChildTypes: ["GMenuItem"],
+        props: internal("MenuProps"),
+        component: internal("createMenuComponent"),
+    },
+    GMenuItem: {
+        component: internal("createMenuItemComponent"),
+        props: { ...internal("MenuItemProps"), constructOnly: ["label", "action"] },
+    },
+    GtkColumnView: {
+        acceptedChildTypes: ["GtkColumnViewColumn"],
+        props: internal("ChildrenProps"),
+    },
+    GtkGrid: {
+        props: internal("ChildrenProps"),
+    },
+    GtkFixed: {
+        props: internal("ChildrenProps"),
+    },
+    GtkSizeGroup: {
+        props: internal("GtkSizeGroupProps"),
+        component: internal("createPortaledComponent"),
+    },
+    GtkConstraintLayout: {
+        component: internal("createConstraintLayoutComponent"),
+        props: internal("GtkConstraintLayoutProps"),
+    },
+    GtkStack: {
+        props: internal("ChildrenProps"),
+        component: internal("createStackComponent"),
+    },
+    GtkNotebook: {
+        props: internal("ChildrenProps"),
+    },
+    GtkApplication: {
+        acceptedChildTypes: ["GtkWindow"],
+        props: { ...internal("GtkApplicationProps"), constructOnly: ["mainOptions"] },
+        component: internal("createApplicationComponent"),
+    },
+    GtkAboutDialog: {
+        props: { ...internal("GtkAboutDialogProps"), constructOnly: ["creditSections"] },
+    },
+    GtkScale: {
+        props: internal("GtkScaleProps"),
+    },
+    GtkCalendar: {
+        props: internal("GtkCalendarProps"),
+    },
+    GtkLevelBar: {
+        props: internal("GtkLevelBarProps"),
+    },
+    GtkDropTarget: {
+        props: internal("GtkDropTargetProps"),
+    },
+    GtkDrawingArea: {
+        props: internal("GtkDrawingAreaProps"),
+    },
+    GtkDragSource: {
+        props: internal("GtkDragSourceProps"),
+    },
+    ...forTypes(CONTENT_SETTER_TYPES, {
+        props: internal("ChildrenProps"),
+        omittedProps: ["content"],
+    }),
+    AdwClampScrollable: {
+        props: internal("ChildrenProps"),
+        omittedProps: ["child"],
+    },
+    AdwViewStackPage: {
+        isLazy: true,
+    },
+    AdwTabPage: {
+        isLazy: true,
+        props: { ...internal("AdwTabPageProps"), constructOnly: ["parent"] },
+    },
+    AdwTabBar: {
+        props: internal("AdwTabDropProps"),
+    },
+    AdwTabOverview: {
+        props: internal("AdwTabDropProps"),
+        omittedProps: ["child"],
+    },
+    AdwAboutDialog: {
+        props: {
+            ...internal("AdwAboutDialogProps"),
+            constructOnly: ["links", "creditSections", "acknowledgementSections", "legalSections", "otherApps"],
+        },
+    },
+    AdwLayout: {
+        isLazy: true,
+    },
+    AdwSidebar: {
+        acceptedChildTypes: ["AdwSidebarSection"],
+        props: internal("ChildrenProps"),
+    },
+    AdwSidebarSection: {
+        acceptedChildTypes: ["AdwSidebarItem"],
+        props: internal("ChildrenProps"),
+    },
+    AdwMultiLayoutView: {
+        props: internal("AdwMultiLayoutViewProps"),
+        component: internal("createMultiLayoutViewComponent"),
+    },
+    AdwPreferencesRow: {
+        props: internal("AdwPreferencesRowProps"),
+    },
+    AdwDialog: {
+        props: internal("AdwBreakpointsProps"),
+        component: internal("createDialogComponent"),
+        omittedProps: ["child"],
+    },
+    AdwApplicationWindow: {
+        props: internal("AdwBreakpointsProps"),
+        omittedProps: ["content"],
+    },
+    AdwWindow: {
+        props: internal("AdwBreakpointsProps"),
+        omittedProps: ["content"],
+    },
+    AdwBreakpointBin: {
+        props: internal("AdwBreakpointsProps"),
+        omittedProps: ["child"],
+    },
+    AdwActionRow: {
+        props: internal("AdwPreferencesRowProps"),
+    },
+    AdwEntryRow: {
+        props: internal("AdwPreferencesRowProps"),
+    },
+    AdwExpanderRow: {
+        props: internal("AdwExpanderRowProps"),
+    },
+    AdwNavigationSplitView: {
+        acceptedChildTypes: ["AdwNavigationPage"],
+        props: internal("ChildrenProps"),
+        omittedProps: ["content"],
+    },
+    AdwWrapBox: {
+        props: internal("ChildrenProps"),
+    },
+    AdwCarousel: {
+        props: internal("ChildrenProps"),
+    },
+    AdwPreferencesPage: {
+        acceptedChildTypes: ["AdwPreferencesGroup"],
+        props: internal("ChildrenProps"),
+    },
+    AdwPreferencesDialog: {
+        acceptedChildTypes: ["AdwPreferencesPage"],
+        props: internal("ChildrenProps"),
+    },
+    AdwPreferencesGroup: {
+        props: internal("ChildrenProps"),
+    },
+    AdwTabView: {
+        props: internal("ChildrenProps"),
+    },
+    AdwNavigationView: {
+        acceptedChildTypes: ["AdwNavigationPage"],
+        props: internal("ChildrenProps"),
+    },
+    AdwViewStack: {
+        props: internal("ChildrenProps"),
+        component: internal("createViewStackComponent"),
+    },
+    AdwToolbarView: {
+        props: internal("AdwToolbarViewProps"),
+        omittedProps: ["content"],
+    },
+    AdwHeaderBar: {
+        props: internal("GtkHeaderBarProps"),
+    },
+    AdwShortcutsDialog: {
+        acceptedChildTypes: ["AdwShortcutsSection"],
+        props: internal("ChildrenProps"),
+    },
+    AdwShortcutsSection: {
+        acceptedChildTypes: ["AdwShortcutsItem"],
+        props: internal("ChildrenProps"),
+    },
+    AdwToggleGroup: {
+        props: { ...internal("AdwToggleGroupProps"), composition: "intersection" },
+        acceptedChildTypes: ["AdwToggle"],
+        component: internal("createToggleGroupComponent"),
+    },
+    AdwAlertDialog: {
+        props: internal("AdwAlertDialogProps"),
+        omittedProps: ["extraChild"],
+    },
+};
+
+export { SINGLE_CHILD_TYPES, CONTENT_SETTER_TYPES, BUILTIN_ELEMENTS };
+
+export type { ElementConfigOptions, ElementPropsExport, ModuleExport } from "./config.ts";

package/src/config-dependencies.ts

@@ -1,15 +1,17 @@
-import { createJiti, type Jiti, type TransformOptions, type TransformResult } from "jiti";
+import { createJiti, type Jiti } from "jiti";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createRequire, registerHooks } from "node:module";
+import { registerHooks } from "node:module";
 import { extname, sep } from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { isRecord } from "./config-error.ts";
+import { configSourceCandidates } from "./config-source.ts";
 
-type CaptureState = { cacheKey: string; dependencies: Set<string>; transformer: Jiti };
+type CaptureState = { cacheKey: string; dependencies: Set<string>; resolver: Jiti };
 type CapturedConfig<T> = { dependencies: string[]; value: T };
 
 const captureStorage: AsyncLocalStorage<CaptureState> = new AsyncLocalStorage();
 const dependenciesByValue: WeakMap<object, string[]> = new WeakMap();
-const CACHE_BUSTED_EXTENSIONS: ReadonlySet<string> = new Set([".cjs", ".js", ".json", ".mjs"]);
+const CACHE_BUSTED_EXTENSIONS: ReadonlySet<string> = new Set([".js", ".json", ".mjs", ".mts", ".ts"]);
 
 const isTrackedPath = (path: string): boolean => !path.includes(`${sep}node_modules${sep}`);
 
@@ -25,8 +27,22 @@ const addUrl = (url: string): void => {
     }
 };
 
+const addConfigSource = (path: string): void => {
+    for (const candidate of configSourceCandidates(path)) {
+        addPath(candidate);
+    }
+};
+
+const addFailedSource = (error: unknown): void => {
+    if (isRecord(error) && typeof error.url === "string" && error.url.startsWith("file:")) {
+        addConfigSource(fileURLToPath(error.url));
+    }
+};
+
 const cacheBustedUrl = (url: string): string => {
-    if (!url.startsWith("file:")) {
+    const state = captureStorage.getStore();
+
+    if (state === undefined || !url.startsWith("file:")) {
         return url;
     }
 
@@ -37,7 +53,7 @@ const cacheBustedUrl = (url: string): string => {
     }
 
     const parsed = new URL(url);
-    parsed.searchParams.set("gtkx-config-load", captureStorage.getStore()?.cacheKey ?? "uncaptured");
+    parsed.searchParams.set("gtkx-config-load", state.cacheKey);
 
     return parsed.href;
 };
@@ -45,49 +61,61 @@ const cacheBustedUrl = (url: string): string => {
 const registerResolutionHook = (): ReturnType<typeof registerHooks> =>
     registerHooks({
         resolve(specifier, context, nextResolve) {
-            const result = nextResolve(specifier, context);
+            let result;
+
+            try {
+                result = nextResolve(specifier, context);
+            } catch (error) {
+                const state = captureStorage.getStore();
+                const fallback = captureStorage.exit(() =>
+                    state?.resolver.esmResolve(specifier, {
+                        ...(context.parentURL !== undefined && { parentURL: context.parentURL }),
+                        try: true,
+                    }),
+                );
+
+                if (fallback === undefined) {
+                    addFailedSource(error);
+                    throw error;
+                }
+
+                result = nextResolve(fallback, context);
+            }
+
             addUrl(result.url);
 
             return { ...result, url: cacheBustedUrl(result.url) };
         },
     });
 
-const clearNativeModuleCache = (dependencies: Iterable<string>): void => {
-    const cache = createRequire(import.meta.url).cache;
-
-    for (const path of dependencies) {
-        Reflect.deleteProperty(cache, path);
-    }
-};
-
-const transformConfigModule = (options: TransformOptions): TransformResult => {
-    const state = captureStorage.getStore();
-
-    if (state === undefined) {
-        throw new Error("Configuration transformation started outside a dependency capture");
+const importConfigModule: Jiti["import"] = async <T>(path: string, options?: { default?: true }): Promise<T> => {
+    if ([".cjs", ".cts"].includes(extname(path))) {
+        throw new Error(`Configuration modules must use ESM: ${path}`);
     }
 
-    if (options.filename !== undefined) {
-        addPath(options.filename);
-    }
+    const value = (await import(pathToFileURL(path).href, {
+        ...(extname(path) === ".json" && { with: { type: "json" } }),
+    })) as Record<string, unknown>;
 
-    return { code: state.transformer.transform(options) };
+    return (options?.default ? (value.default ?? { ...value }) : value) as T;
 };
 
+const createConfigImporter = (): Jiti =>
+    Object.assign(createJiti(import.meta.url, { fsCache: false, moduleCache: false }), { import: importConfigModule });
+
 const setConfigDependencies = (value: object, dependencies: Iterable<string>): void => {
     const paths = [...new Set(dependencies)];
     dependenciesByValue.set(value, paths);
-    clearNativeModuleCache(paths);
 };
 
 const configDependenciesFor = (value: unknown): string[] =>
-    typeof value === "object" && value !== null ? dependenciesByValue.get(value) ?? [] : [];
+    typeof value === "object" && value !== null ? (dependenciesByValue.get(value) ?? []) : [];
 
 const captureConfigDependencies = async <T>(operation: () => Promise<T>): Promise<CapturedConfig<T>> => {
     const state: CaptureState = {
         cacheKey: process.hrtime.bigint().toString(),
         dependencies: new Set(),
-        transformer: createJiti(import.meta.url, { fsCache: false, moduleCache: false }),
+        resolver: createJiti(import.meta.url, { fsCache: false, moduleCache: false }),
     };
     const hook = registerResolutionHook();
 
@@ -106,9 +134,17 @@ const captureConfigDependencies = async <T>(operation: () => Promise<T>): Promis
     }
 };
 
+const loadConfigModule = async (path: string): Promise<unknown> => {
+    const captured = await captureConfigDependencies(() => importConfigModule(path, { default: true }));
+
+    return captured.value;
+};
+
 export {
+    addConfigSource,
     captureConfigDependencies,
     configDependenciesFor,
+    createConfigImporter,
+    loadConfigModule,
     setConfigDependencies,
-    transformConfigModule,
 };

package/src/config-error.ts

@@ -8,9 +8,11 @@ const isRecord = (value: unknown): value is Record<string, unknown> =>
 const configPrefix = (configFile: string): string => `${configFile}:`;
 
 const missingConfigFileError = (cwd: string, configFile?: string): Error =>
-    new Error(configFile === undefined
-        ? `${configPrefix(DEFAULT_CONFIG_FILE)} no configuration file found in ${cwd}`
-        : `${configPrefix(configFile)} no configuration file found in ${cwd}`);
+    new Error(
+        configFile === undefined
+            ? `${configPrefix(DEFAULT_CONFIG_FILE)} no configuration file found in ${cwd}`
+            : `${configPrefix(configFile)} no configuration file found in ${cwd}`,
+    );
 
 const configError = (error: z.ZodError, configFile = DEFAULT_CONFIG_FILE): Error =>
     new Error(`${configPrefix(configFile)}\n${z.prettifyError(error)}`);

package/src/config-reloader.ts

@@ -0,0 +1,45 @@
+import { resolve } from "node:path";
+import { configDependenciesFor } from "./config-dependencies.ts";
+import { loadConfig, type LoadConfigOptions, type LoadedConfig } from "./loader.ts";
+
+type ConfigReloader = {
+    reload: () => Promise<LoadedConfig>;
+    resolvePaths: () => string[];
+};
+
+const createConfigReloader = async (
+    cwd: string,
+    options: LoadConfigOptions = {},
+    initialDependencies: string[] = [],
+): Promise<ConfigReloader> => {
+    let selectedConfigFile: string;
+    let knownDependencies = initialDependencies;
+
+    if (options.configFile === undefined) {
+        const loaded = await loadConfig(cwd, options);
+        selectedConfigFile = loaded.configFile;
+        knownDependencies = [...knownDependencies, ...configDependenciesFor(loaded)];
+    } else {
+        selectedConfigFile = resolve(cwd, options.configFile);
+    }
+
+    return {
+        resolvePaths: () => [...new Set([selectedConfigFile, ...knownDependencies])],
+        reload: async () => {
+            let loaded: LoadedConfig;
+
+            try {
+                loaded = await loadConfig(cwd, { ...options, configFile: selectedConfigFile });
+            } catch (error) {
+                knownDependencies = [...new Set([...knownDependencies, ...configDependenciesFor(error)])];
+                throw error;
+            }
+
+            knownDependencies = configDependenciesFor(loaded);
+
+            return loaded;
+        },
+    };
+};
+
+export { createConfigReloader };

package/src/config-source.ts

@@ -0,0 +1,48 @@
+import { SUPPORTED_EXTENSIONS } from "c12";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
+
+type ConfigResolutionOptions = { configFile?: string | undefined; cwd?: string | undefined };
+
+const CONFIG_LOCATIONS = ["gtkx.config", ".config/gtkx", ".config/gtkx.config"];
+const CONFIG_EXTENSIONS = SUPPORTED_EXTENSIONS.filter((extension) => extension !== ".cjs" && extension !== ".cts");
+
+const configCandidatePaths = (directory: string): string[] =>
+    CONFIG_LOCATIONS.flatMap((location) =>
+        CONFIG_EXTENSIONS.map((extension) => join(directory, `${location}${extension}`)),
+    );
+
+const configSourceCandidates = (path: string): string[] => {
+    const extension = extname(path);
+    const fallback = extension === ".js" ? ".ts" : extension === ".mjs" ? ".mts" : undefined;
+
+    if (extension.length > 0) {
+        return fallback === undefined ? [path] : [path, `${path.slice(0, -extension.length)}${fallback}`];
+    }
+
+    return [
+        path,
+        ...CONFIG_EXTENSIONS.flatMap((candidate) => [`${path}${candidate}`, join(path, `index${candidate}`)]),
+    ];
+};
+
+const isLocalConfigSource = (source: string): boolean => source.startsWith(".") || isAbsolute(source);
+
+const isDirectoryConfigSource = (source: string): boolean => {
+    const extension = extname(source);
+
+    return extension.length === 0 || extension === basename(source);
+};
+
+const localConfigSourcePath = (source: string, options: ConfigResolutionOptions): string | undefined => {
+    if (source === "." || !isLocalConfigSource(source)) {
+        return undefined;
+    }
+
+    const cwd = options.cwd ?? process.cwd();
+
+    return isDirectoryConfigSource(source)
+        ? resolve(cwd, source, options.configFile ?? "gtkx.config")
+        : resolve(cwd, source);
+};
+
+export { configCandidatePaths, configSourceCandidates, localConfigSourcePath, type ConfigResolutionOptions };