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

package/src/config.ts

@@ -25,13 +25,11 @@ type ResolvedReactCompilerOptions = ReactCompilerOptions & {
 };
 
 /**
- * User-facing configuration for a GTKX project, as authored in `gtkx.config.ts`: the GIR libraries
- * to bind and where to find them, the GApplication id, per-element configuration, the React
- * Compiler, codegen, and user event signal settings, and the `agents` and `mcp` blocks controlling
- * what coding agents are given.
+ * GTKX project configuration authored in `gtkx.config.ts` and validated when loaded.
  */
 type Config = z.infer<typeof configSchema>;
 type ModuleExport = z.infer<typeof moduleExportSchema>;
+type ElementPropsExport = z.infer<typeof elementPropsSchema>;
 type ElementConfigEntry = z.infer<typeof elementConfigSchema>;
 
 type McpSettings = {
@@ -80,7 +78,7 @@ const applicationIdSchema = z
 
 const reactCompilerSchema = z.union([
     z.boolean(),
-    z.object({
+    z.strictObject({
         compilationMode: z.enum(COMPILATION_MODES).optional(),
         panicThreshold: z.enum(PANIC_THRESHOLDS).optional(),
     }),
@@ -97,7 +95,7 @@ const userEventSignalsSchema = z.record(
     { error: "must be a record of GLib type names to signal name arrays" },
 );
 
-const moduleExportSchema = z.object(
+const moduleExportSchema = z.strictObject(
     {
         module: z.string({ error: "must be a module specifier" }).min(1, { error: "must be a module specifier" }),
         export: z.string({ error: "must be an export name" }).min(1, { error: "must be an export name" }),
@@ -105,10 +103,16 @@ const moduleExportSchema = z.object(
     { error: "must be a { module, export } object" },
 );
 
-const elementConfigSchema = z.object({
+const elementPropsSchema = moduleExportSchema.extend({
+    composition: z.enum(["factory", "intersection"]).optional(),
+    constructOnly: z.array(z.string()).optional(),
+});
+
+const elementConfigSchema = z.strictObject({
     component: moduleExportSchema.optional(),
-    props: moduleExportSchema.optional(),
+    props: elementPropsSchema.optional(),
     isLazy: z.boolean({ error: "must be a boolean" }).optional(),
+    acceptedChildTypes: z.array(z.string()).optional(),
     omittedProps: z
         .array(
             z.string({ error: "must be a non-empty property name" }).min(1, {
@@ -119,7 +123,7 @@ const elementConfigSchema = z.object({
         .optional(),
 });
 
-const elementsSchema = z.object({
+const elementsSchema = z.strictObject({
     behaviors: z
         .string({ error: "must be a path to a module exporting element behaviors" })
         .min(1, { error: "must be a path to a module exporting element behaviors" })
@@ -127,12 +131,12 @@ const elementsSchema = z.object({
     config: z.record(z.string(), elementConfigSchema).optional(),
 });
 
-const agentsSchema = z.object({
+const agentsSchema = z.strictObject({
     rules: z.boolean({ error: "must be a boolean" }).optional(),
     reference: z.boolean({ error: "must be a boolean" }).optional(),
 });
 
-const mcpSchema = z.object({
+const mcpSchema = z.strictObject({
     tools: z
         .array(z.string({ error: "must be a tool name pattern" }).min(1, { error: "must be a tool name pattern" }), {
             error: "must be an array of tool name patterns",
@@ -153,7 +157,7 @@ const graduatedFutureSchema = z
     })
     .strict();
 
-const deprecationsSchema = z.object({
+const deprecationsSchema = z.strictObject({
     silence: z
         .array(z.never({ error: "does not name a current deprecation" }), {
             error: "must be an array of current deprecation ids",
@@ -162,7 +166,7 @@ const deprecationsSchema = z.object({
 });
 
 /** Schema every `gtkx.config.ts` is validated against, and the source of the {@link Config} type. */
-const configSchema = z.object({
+const configSchema = z.strictObject({
     libraries: librariesSchema.optional(),
     girPath: z.array(z.string(), { error: "must be an array of strings if provided" }).optional(),
     applicationId: applicationIdSchema,
@@ -251,9 +255,12 @@ const elementEntryValues = <T>(
 const resolveElementComponents = (elements: Config["elements"]): Record<string, ModuleExport> =>
     elementEntryValues(elements, (entry) => entry.component);
 
-const resolveElementProps = (elements: Config["elements"]): Record<string, ModuleExport> =>
+const resolveElementProps = (elements: Config["elements"]): Record<string, ElementPropsExport> =>
     elementEntryValues(elements, (entry) => entry.props);
 
+const resolveAcceptedChildTypes = (elements: Config["elements"]): Record<string, string[]> =>
+    elementEntryValues(elements, (entry) => entry.acceptedChildTypes);
+
 const resolveOmittedProps = (elements: Config["elements"]): Record<string, string[]> =>
     elementEntryValues(elements, (entry) => entry.omittedProps);
 
@@ -285,6 +292,7 @@ export {
     resolveLazyElements,
     resolveElementComponents,
     resolveElementProps,
+    resolveAcceptedChildTypes,
     resolveMcpSettings,
     resolveOmittedProps,
     resolveConfig,

package/src/deploy.ts

@@ -10,7 +10,6 @@ import {
     url,
 } from "./schema-text.ts";
 
-const APPIMAGE_COMPRESSIONS = ["gzip", "xz", "zstd"] as const;
 const DEB_COMPRESSIONS = ["gzip", "none", "xz", "zstd"] as const;
 const DEB_SIGN_METHODS = ["debsign", "dpkg-sig"] as const;
 const DEB_SIGN_TYPES = ["archive", "maint", "origin"] as const;
@@ -160,7 +159,7 @@ type DeployNodeOptions = Partial<
     Record<"path", string | undefined> &
     Record<"shouldStrip" | "shouldUseCompileCache", boolean | undefined>
 > & {
-    /** Expected Node.js version. Downloaded runtimes default to exactly 26.7.0 when omitted. */
+    /** Expected Node.js version. Downloaded runtimes default to exactly 26.8.2 when omitted. */
     version?: string | undefined;
 };
 const nodeRuntimeSchema: z.ZodType<DeployNodeOptions> = z.strictObject({
@@ -196,7 +195,7 @@ const rpmSchema = z.strictObject({
 
 const appimageSchema = z.strictObject({
     fileName: text("must be an output file name").optional(),
-    compression: z.enum(APPIMAGE_COMPRESSIONS, { error: "must be one of gzip, xz, zstd" }).optional(),
+    compression: z.literal("zstd", { error: "must be zstd" }).optional(),
     updateInformation: text("must be an AppImage update information string").optional(),
     runtimeFile: text("must be a path to an AppImage runtime file").optional(),
 });

package/src/internal.ts

@@ -1,10 +1,12 @@
 export { configDependenciesFor } from "./config-dependencies.ts";
+export { createConfigReloader } from "./config-reloader.ts";
 export type { McpSettings, ResolvedReactCompilerOptions } from "./config.ts";
 export {
     APPLICATION_ID_MAX_LENGTH,
     isAgentReferenceEnabled,
     isAgentRulesEnabled,
     isValidApplicationId,
+    resolveAcceptedChildTypes,
     resolveElementComponents,
     resolveElementProps,
     resolveLazyElements,
@@ -12,6 +14,7 @@ export {
     resolveOmittedProps,
 } from "./config.ts";
 export { createConfigLoader } from "./loader.ts";
-export { assertSupportedNodeVersion, MINIMUM_NODE_VERSION } from "./node-version.ts";
+export { assertSupportedNodeVersion, DEFAULT_NODE_VERSION, MINIMUM_NODE_VERSION } from "./node-version.ts";
 export { resourceBasePath } from "./resource-base-path.ts";
 export { viteProjectRoot } from "./vite-root.ts";
+export { SUPPORTED_EXTENSIONS as CONFIG_EXTENSIONS } from "c12";

package/src/loader.ts

@@ -1,13 +1,14 @@
 import { isPathInside, warn } from "@gtkx/utils";
 import { loadConfig as loadConfigFile } from "c12";
 import { existsSync } from "node:fs";
-import { basename, extname, isAbsolute, relative, resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import {
     captureConfigDependencies,
     setConfigDependencies,
     transformConfigModule,
 } from "./config-dependencies.ts";
 import { missingConfigFileError } from "./config-error.ts";
+import { type ConfigResolutionOptions, localConfigSourcePath } from "./config-source.ts";
 import {
     type Config,
     graduatedFutureKeys,
@@ -47,28 +48,6 @@ type ConfigLoader = {
 const GRADUATED_FUTURE_ENV = "GTKX_GRADUATED_FUTURE_SHOWN";
 const graduatedFutureWarnings: Map<string, string> = new Map();
 
-type ConfigResolutionOptions = { configFile?: string | undefined; cwd?: string | undefined };
-
-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);
-};
-
 const rejectMissingLocalConfig = (source: string, options: ConfigResolutionOptions): undefined => {
     const path = localConfigSourcePath(source, options);
 
@@ -138,6 +117,7 @@ const loadConfig = async (cwd: string, options: LoadConfigOptions = {}): Promise
             rcFile: false,
             globalRc: false,
             packageJson: false,
+            omit$Keys: true,
             context: { mode: options.mode },
             jitiOptions: { fsCache: false, transform: transformConfigModule },
             resolve: rejectMissingLocalConfig,
@@ -198,4 +178,4 @@ const createConfigLoader = (options: LoadConfigOptions = {}): ConfigLoader => {
     };
 };
 
-export { loadConfig, createConfigLoader, type LoadedConfig, type ConfigLoader };
+export { loadConfig, createConfigLoader, type LoadedConfig, type ConfigLoader, type LoadConfigOptions };

package/src/node-version.ts

@@ -1,6 +1,7 @@
 const MINIMUM_NODE_MAJOR = 26;
 const MINIMUM_NODE_MINOR = 7;
 const MINIMUM_NODE_VERSION = "26.7.0";
+const DEFAULT_NODE_VERSION = "26.8.2";
 
 const assertSupportedNodeVersion = (): void => {
     const [major = 0, minor = 0] = process.versions.node.split(".").map(Number);
@@ -13,4 +14,4 @@ const assertSupportedNodeVersion = (): void => {
     }
 };
 
-export { assertSupportedNodeVersion, MINIMUM_NODE_VERSION };
+export { assertSupportedNodeVersion, DEFAULT_NODE_VERSION, MINIMUM_NODE_VERSION };

package/src/static-dependencies.ts

@@ -0,0 +1,464 @@
+import { parseSync, traverse, types } from "@babel/core";
+import { parseJSON, parseJSON5, parseJSONC, parseTOML, parseYAML } from "confbox";
+import { createJiti, type Jiti } from "jiti";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, resolve, sep } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { localConfigSourcePath } from "./config-source.ts";
+
+const MODULE_EXTENSIONS: ReadonlySet<string> = new Set([
+    ".cjs",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".mts",
+    ".ts",
+]);
+const RESOLVABLE_EXTENSIONS = [
+    ".js",
+    ".ts",
+    ".mjs",
+    ".cjs",
+    ".mts",
+    ".cts",
+    ".json",
+    ".jsonc",
+    ".json5",
+    ".yaml",
+    ".yml",
+    ".toml",
+];
+const JAVASCRIPT_FALLBACKS: Readonly<Record<string, string[]>> = {
+    ".cjs": [".cts"],
+    ".js": [".ts"],
+    ".jsx": [".tsx"],
+    ".mjs": [".mts"],
+};
+const DATA_PARSERS: Readonly<Record<string, (source: string) => unknown>> = {
+    ".json": parseJSON,
+    ".json5": parseJSON5,
+    ".jsonc": parseJSONC,
+    ".toml": parseTOML,
+    ".yaml": parseYAML,
+    ".yml": parseYAML,
+};
+
+type PackageImports = { file: string; imports: Record<string, unknown>; root: string };
+type ModuleSources = { all: string[]; extended: string[] };
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null && !Array.isArray(value);
+
+const parserPlugins = (path: string): ("decorators" | "jsx" | "typescript")[] => {
+    const extension = extname(path).toLowerCase();
+
+    return [
+        "decorators",
+        ...([".cts", ".mts", ".ts"].includes(extension) ? ["typescript" as const] : []),
+    ];
+};
+
+function expressionSources(value: types.Expression): string[] {
+    if (types.isStringLiteral(value)) {
+        return [value.value];
+    }
+
+    if (types.isArrayExpression(value)) {
+        return value.elements.flatMap((element) =>
+            types.isExpression(element) ? expressionSources(element) : []);
+    }
+
+    return types.isObjectExpression(value)
+        ? value.properties.flatMap((property) => sourcePropertySources(property))
+        : [];
+}
+
+const isNamedProperty = (property: types.ObjectProperty, name: string): boolean =>
+    (types.isIdentifier(property.key) && property.key.name === name) ||
+    (types.isStringLiteral(property.key) && property.key.value === name);
+
+function sourcePropertySources(
+    property: types.ObjectMethod | types.ObjectProperty | types.SpreadElement,
+): string[] {
+    return types.isObjectProperty(property) &&
+        isNamedProperty(property, "source") &&
+        types.isExpression(property.value)
+        ? expressionSources(property.value)
+        : [];
+}
+
+const extendsSources = (value: types.Expression): string[] => expressionSources(value);
+
+const isExtendsProperty = (property: types.ObjectProperty): boolean =>
+    isNamedProperty(property, "extends");
+
+type ParsedModule = NonNullable<ReturnType<typeof parseSync>>;
+
+const parseModule = (path: string): ParsedModule | undefined => {
+    try {
+        return parseSync(readFileSync(path, "utf8"), {
+            ast: true,
+            babelrc: false,
+            configFile: false,
+            filename: path,
+            parserOpts: { allowReturnOutsideFunction: true, plugins: parserPlugins(path) },
+            sourceType: "unambiguous",
+        }) ?? undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+const addSource = (sources: Set<string>, source: types.StringLiteral | null | undefined): void => {
+    if (source !== null && source !== undefined) {
+        sources.add(source.value);
+    }
+};
+
+const requireSource = (call: types.CallExpression): types.StringLiteral | undefined =>
+    types.isIdentifier(call.callee, { name: "require" }) && types.isStringLiteral(call.arguments[0])
+        ? call.arguments[0]
+        : undefined;
+
+const importEqualsSource = (declaration: types.TSImportEqualsDeclaration): types.StringLiteral | undefined => {
+    const { moduleReference } = declaration;
+
+    return types.isTSExternalModuleReference(moduleReference) ? moduleReference.expression : undefined;
+};
+
+const propertySources = (property: types.ObjectProperty): string[] =>
+    isExtendsProperty(property) && types.isExpression(property.value)
+        ? extendsSources(property.value)
+        : [];
+
+const collectModuleSources = (ast: ParsedModule): ModuleSources => {
+    const sources: Set<string> = new Set();
+    const extended: Set<string> = new Set();
+
+    traverse(ast, {
+        CallExpression: (nodePath) => {
+            addSource(sources, requireSource(nodePath.node));
+        },
+        ExportAllDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ExportNamedDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ImportDeclaration: (nodePath) => {
+            addSource(sources, nodePath.node.source);
+        },
+        ImportExpression: (nodePath) => {
+            const { source } = nodePath.node;
+            addSource(sources, types.isStringLiteral(source) ? source : undefined);
+        },
+        ObjectProperty: (nodePath) => {
+            for (const source of propertySources(nodePath.node)) {
+                sources.add(source);
+                extended.add(source);
+            }
+        },
+        TSImportEqualsDeclaration: (nodePath) => {
+            addSource(sources, importEqualsSource(nodePath.node));
+        },
+    });
+
+    return { all: [...sources], extended: [...extended] };
+};
+
+const moduleSources = (path: string): ModuleSources => {
+    const ast = parseModule(path);
+
+    return ast === undefined ? { all: [], extended: [] } : collectModuleSources(ast);
+};
+
+function parsedExtendsSources(value: unknown): string[] {
+    if (typeof value === "string") {
+        return [value];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => parsedExtendsSources(item));
+    }
+
+    return objectExtendsSources(value);
+}
+
+const objectExtendsSources = (value: unknown): string[] => {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+
+    return "source" in value ? parsedExtendsSources(value.source) : [];
+};
+
+const configExtendsSources = (value: unknown): string[] => {
+    if (typeof value !== "object" || value === null) {
+        return [];
+    }
+
+    return "extends" in value ? parsedExtendsSources(value.extends) : [];
+};
+
+const dataSources = (path: string): string[] => {
+    const parser = DATA_PARSERS[extname(path).toLowerCase()];
+
+    if (parser === undefined) {
+        return [];
+    }
+
+    try {
+        return configExtendsSources(parser(readFileSync(path, "utf8")));
+    } catch {
+        return [];
+    }
+};
+
+const extensionCandidates = (path: string): string[] => {
+    const extension = extname(path).toLowerCase();
+
+    if (extension.length === 0) {
+        return RESOLVABLE_EXTENSIONS.map((candidate) => `${path}${candidate}`);
+    }
+
+    const stem = path.slice(0, -extension.length);
+
+    return (JAVASCRIPT_FALLBACKS[extension] ?? []).map((candidate) => `${stem}${candidate}`);
+};
+
+const targetCandidates = (target: string, configName: string): string[] => {
+    const extension = extname(target);
+
+    if (extension.length > 0) {
+        return [target, ...extensionCandidates(target)];
+    }
+
+    return [
+        target,
+        ...extensionCandidates(target),
+        join(target, configName),
+        ...RESOLVABLE_EXTENSIONS.map((candidate) => join(target, `index${candidate}`)),
+    ];
+};
+
+const localSourceTarget = (source: string, importer: string): string | undefined => {
+    const clean = source.split(/[?#]/u, 1)[0] ?? "";
+
+    if (clean.startsWith("file:")) {
+        return fileURLToPath(clean);
+    }
+
+    if (!isAbsolute(clean) && !clean.startsWith(".")) {
+        return undefined;
+    }
+
+    return resolve(dirname(importer), clean);
+};
+
+const unresolvedCandidates = (source: string, importer: string, configName: string): string[] => {
+    const target = localSourceTarget(source, importer);
+
+    if (target === undefined) {
+        return [];
+    }
+
+    return targetCandidates(target, configName);
+};
+
+const nearestPackageFile = (importer: string): string | undefined => {
+    let directory = dirname(importer);
+    let previous = "";
+
+    while (directory !== previous) {
+        const candidate = join(directory, "package.json");
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+
+        previous = directory;
+        directory = dirname(directory);
+    }
+
+    return undefined;
+};
+
+const readPackageImports = (importer: string): PackageImports | undefined => {
+    const file = nearestPackageFile(importer);
+
+    if (file === undefined) {
+        return undefined;
+    }
+
+    try {
+        const manifest = parseJSON(readFileSync(file, "utf8"));
+
+        return isRecord(manifest) && isRecord(manifest.imports)
+            ? { file, imports: manifest.imports, root: dirname(file) }
+            : undefined;
+    } catch {
+        return undefined;
+    }
+};
+
+function stringTargets(value: unknown): string[] {
+    if (typeof value === "string") {
+        return [value];
+    }
+
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => stringTargets(item));
+    }
+
+    return isRecord(value)
+        ? Object.values(value).flatMap((item) => stringTargets(item))
+        : [];
+}
+
+const importPatternMatch = (pattern: string, source: string): string | undefined => {
+    if (pattern === source) {
+        return "";
+    }
+
+    const wildcard = pattern.indexOf("*");
+
+    if (wildcard === -1) {
+        return undefined;
+    }
+
+    const prefix = pattern.slice(0, wildcard);
+    const suffix = pattern.slice(wildcard + 1);
+
+    return source.startsWith(prefix) && source.endsWith(suffix)
+        ? source.slice(prefix.length, source.length - suffix.length)
+        : undefined;
+};
+
+const packageImportTargets = (source: string, imports: Record<string, unknown>): string[] =>
+    Object.entries(imports).flatMap(([pattern, value]) => {
+        const match = importPatternMatch(pattern, source);
+
+        return match === undefined
+            ? []
+            : stringTargets(value).map((target) => target.split("*").join(match));
+    });
+
+const packageImportDependencies = (source: string, importer: string, configName: string): string[] => {
+    if (!source.startsWith("#")) {
+        return [];
+    }
+
+    const packageImports = readPackageImports(importer);
+
+    if (packageImports === undefined) {
+        return [];
+    }
+
+    const targets = packageImportTargets(source, packageImports.imports)
+        .filter((target) => target.startsWith("."))
+        .flatMap((target) => targetCandidates(resolve(packageImports.root, target), configName));
+
+    return [packageImports.file, ...targets];
+};
+
+const normalizedResolvedPath = (path: string): string =>
+    path.startsWith("file:") ? fileURLToPath(path) : path;
+
+const resolvedSourcePath = (source: string, importer: string, jiti: Jiti): string | undefined => {
+    try {
+        const path = jiti.esmResolve(source, {
+            parentURL: pathToFileURL(importer).href,
+            try: true,
+        });
+
+        return path === undefined ? undefined : normalizedResolvedPath(path);
+    } catch {
+        return undefined;
+    }
+};
+
+const sourceDependencies = (
+    source: string,
+    importer: string,
+    configName: string,
+    jiti: Jiti,
+): string[] => {
+    const dependency = resolvedSourcePath(source, importer, jiti);
+    const packageDependencies = packageImportDependencies(source, importer, configName);
+
+    return dependency === undefined
+        ? [...unresolvedCandidates(source, importer, configName), ...packageDependencies]
+        : [dependency, ...packageDependencies];
+};
+
+const configLayerDirectory = (path: string, configName: string, configRoot: string): string => {
+    const segments = configName.split(/[\\/]/u).filter((segment) => segment.length > 0);
+    let directory = resolve(path);
+    let remaining = segments.length;
+
+    while (remaining > 0) {
+        directory = dirname(directory);
+        remaining -= 1;
+    }
+
+    return resolve(directory, ...segments) === resolve(path) ? directory : resolve(configRoot);
+};
+
+const c12SourceDependencies = (
+    source: string,
+    importer: string,
+    configName: string,
+    configRoot: string,
+): string[] => {
+    const clean = source.split(/[?#]/u, 1)[0] ?? "";
+
+    const cwd = configLayerDirectory(importer, configName, configRoot);
+    const target = localConfigSourcePath(clean, { cwd, configFile: configName });
+
+    return target === undefined ? [] : targetCandidates(target, configName);
+};
+
+const directDependencies = (path: string, configName: string, configRoot: string): string[] => {
+    const module = MODULE_EXTENSIONS.has(extname(path).toLowerCase()) ? moduleSources(path) : undefined;
+    const sources = module?.all ?? dataSources(path);
+    const extended = module?.extended ?? sources;
+    const jiti = createJiti(path, {
+        extensions: RESOLVABLE_EXTENSIONS,
+        fsCache: false,
+        moduleCache: false,
+    });
+
+    return [
+        ...sources.flatMap((source) => sourceDependencies(source, path, configName, jiti)),
+        ...extended.flatMap((source) => c12SourceDependencies(source, path, configName, configRoot)),
+    ]
+        .filter((dependency) => !dependency.includes(`${sep}node_modules${sep}`));
+};
+
+const resolveConfigDependencies = (
+    configFile: string,
+    configName = basename(configFile),
+    configRoot = dirname(configFile),
+): string[] => {
+    const dependencies: Set<string> = new Set();
+    const pending = [resolve(configFile)];
+
+    while (pending.length > 0) {
+        const path = pending.pop();
+
+        if (path === undefined) {
+            break;
+        }
+
+        if (dependencies.has(path)) {
+            continue;
+        }
+
+        dependencies.add(path);
+        pending.push(...directDependencies(path, configName, configRoot));
+    }
+
+    return [...dependencies];
+};
+
+export { resolveConfigDependencies };