dotcom-tool-kit 3.5.0 → 4.0.0-beta.1

package/lib/plugin/merge-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-hooks.d.ts","sourceRoot":"","sources":["../../src/plugin/merge-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAGjE,eAAO,MAAM,UAAU,WAAY,kBAAkB,UAAU,MAAM,SAwBpE,CAAA"}

package/lib/plugin/merge-hooks.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeHooks = void 0;
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+const mergeHooks = (config, plugin) => {
+    if (plugin.rcFile) {
+        // add hooks to the registry, handling any conflicts
+        // TODO refactor with command conflict handler
+        for (const [hookName, hookSpec] of Object.entries(plugin.rcFile.installs || {})) {
+            const existingHookId = config.hooks[hookName];
+            const entryPoint = {
+                plugin,
+                modulePath: hookSpec.entryPoint
+            };
+            if (existingHookId) {
+                const conflicting = (0, conflict_1.isConflict)(existingHookId) ? existingHookId.conflicting : [existingHookId];
+                config.hooks[hookName] = {
+                    plugin,
+                    conflicting: conflicting.concat(entryPoint)
+                };
+            }
+            else {
+                config.hooks[hookName] = entryPoint;
+                hookSpec.managesFiles?.forEach((file) => config.hookManagedFiles.add(file));
+            }
+        }
+    }
+};
+exports.mergeHooks = mergeHooks;

package/lib/plugin/merge-inits.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@dotcom-tool-kit/plugin';
+import type { ValidPluginsConfig } from '@dotcom-tool-kit/config';
+export declare const mergeInits: (config: ValidPluginsConfig, plugin: Plugin) => void;
+//# sourceMappingURL=merge-inits.d.ts.map

package/lib/plugin/merge-inits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-inits.d.ts","sourceRoot":"","sources":["../../src/plugin/merge-inits.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAEjE,eAAO,MAAM,UAAU,WAAY,kBAAkB,UAAU,MAAM,SAUpE,CAAA"}

package/lib/plugin/merge-inits.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeInits = void 0;
+const mergeInits = (config, plugin) => {
+    if (plugin.rcFile) {
+        // no conflict resolution needed; we'll just run them all ig
+        config.inits.push(...plugin.rcFile.init.map((init) => ({
+            plugin,
+            modulePath: init
+        })));
+    }
+};
+exports.mergeInits = mergeInits;

package/lib/plugin/merge-plugin-options.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@dotcom-tool-kit/plugin';
+import type { ValidPluginsConfig } from '@dotcom-tool-kit/config';
+export declare const mergePluginOptions: (config: ValidPluginsConfig, plugin: Plugin) => void;
+//# sourceMappingURL=merge-plugin-options.d.ts.map

package/lib/plugin/merge-plugin-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-plugin-options.d.ts","sourceRoot":"","sources":["../../src/plugin/merge-plugin-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAoB,MAAM,yBAAyB,CAAA;AACvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAMjE,eAAO,MAAM,kBAAkB,WAAY,kBAAkB,UAAU,MAAM,SAwC5E,CAAA"}

package/lib/plugin/merge-plugin-options.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergePluginOptions = void 0;
+const is_descendent_1 = require("./is-descendent");
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+// merge options from this plugin's config with any options we've collected already
+// TODO this is almost the exact same code as for command tasks, refactor
+const mergePluginOptions = (config, plugin) => {
+    if (plugin.rcFile) {
+        for (const [id, configOptions] of Object.entries(plugin.rcFile.options.plugins)) {
+            // users can specify root options with the dotcom-tool-kit key to mirror
+            // the name of the root npm package
+            const pluginId = id === 'dotcom-tool-kit' ? 'app root' : id;
+            const existingOptions = config.pluginOptions[pluginId];
+            const pluginOptions = {
+                options: configOptions,
+                plugin,
+                forPlugin: config.plugins[pluginId]
+            };
+            if (existingOptions) {
+                const existingFromDescendent = (0, is_descendent_1.isDescendent)(plugin, existingOptions.plugin);
+                // plugins can only override options from their descendents, otherwise it's a conflict
+                // return a conflict either listing these options and the sibling's,
+                // or merging in previously-generated options
+                if (!existingFromDescendent) {
+                    const conflicting = (0, conflict_1.isConflict)(existingOptions) ? existingOptions.conflicting : [existingOptions];
+                    const conflict = {
+                        plugin,
+                        conflicting: conflicting.concat(pluginOptions)
+                    };
+                    config.pluginOptions[pluginId] = conflict;
+                }
+                else {
+                    // if we're here, any existing options are from a child plugin,
+                    // so merge in overrides from the parent
+                    config.pluginOptions[pluginId] = { ...existingOptions, ...pluginOptions };
+                }
+            }
+            else {
+                // this options key might not have been set yet, in which case use the new one
+                config.pluginOptions[pluginId] = pluginOptions;
+            }
+        }
+    }
+};
+exports.mergePluginOptions = mergePluginOptions;

package/lib/plugin/merge-task-options.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@dotcom-tool-kit/plugin';
+import type { ValidPluginsConfig } from '@dotcom-tool-kit/config';
+export declare const mergeTaskOptions: (config: ValidPluginsConfig, plugin: Plugin) => void;
+//# sourceMappingURL=merge-task-options.d.ts.map

package/lib/plugin/merge-task-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-task-options.d.ts","sourceRoot":"","sources":["../../src/plugin/merge-task-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAkB,MAAM,yBAAyB,CAAA;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAOjE,eAAO,MAAM,gBAAgB,WAAY,kBAAkB,UAAU,MAAM,SAqC1E,CAAA"}

package/lib/plugin/merge-task-options.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTaskOptions = void 0;
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+const is_descendent_1 = require("./is-descendent");
+// merge options from this plugin's config with any options we've collected already
+// TODO this is almost the exact same code as for command tasks, refactor
+const mergeTaskOptions = (config, plugin) => {
+    if (plugin.rcFile) {
+        for (const [taskId, configOptions] of Object.entries(plugin.rcFile.options.tasks)) {
+            const existingOptions = config.taskOptions[taskId];
+            const taskOptions = {
+                options: configOptions,
+                plugin,
+                task: taskId
+            };
+            if (existingOptions) {
+                const existingFromDescendent = (0, is_descendent_1.isDescendent)(plugin, existingOptions.plugin);
+                // plugins can only override options from their descendents, otherwise it's a conflict
+                // return a conflict either listing these options and the sibling's,
+                // or merging in previously-generated options
+                if (!existingFromDescendent) {
+                    const conflicting = (0, conflict_1.isConflict)(existingOptions) ? existingOptions.conflicting : [existingOptions];
+                    const conflict = {
+                        plugin,
+                        conflicting: conflicting.concat(taskOptions)
+                    };
+                    config.taskOptions[taskId] = conflict;
+                }
+                else {
+                    // if we're here, any existing options are from a child plugin,
+                    // so merge in overrides from the parent
+                    config.taskOptions[taskId] = { ...existingOptions, ...taskOptions };
+                }
+            }
+            else {
+                // this options key might not have been set yet, in which case use the new one
+                config.taskOptions[taskId] = taskOptions;
+            }
+        }
+    }
+};
+exports.mergeTaskOptions = mergeTaskOptions;

package/lib/plugin/merge-tasks.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '@dotcom-tool-kit/plugin';
+import type { ValidPluginsConfig } from '@dotcom-tool-kit/config';
+export declare const mergeTasks: (config: ValidPluginsConfig, plugin: Plugin) => void;
+//# sourceMappingURL=merge-tasks.d.ts.map

package/lib/plugin/merge-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-tasks.d.ts","sourceRoot":"","sources":["../../src/plugin/merge-tasks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAIjE,eAAO,MAAM,UAAU,WAAY,kBAAkB,UAAU,MAAM,SAqBpE,CAAA"}

package/lib/plugin/merge-tasks.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeTasks = void 0;
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+// add plugin tasks to our task registry, handling any conflicts
+const mergeTasks = (config, plugin) => {
+    if (plugin.rcFile) {
+        for (const [taskName, modulePath] of Object.entries(plugin.rcFile.tasks || {})) {
+            const existingTaskId = config.tasks[taskName];
+            const entryPoint = {
+                plugin,
+                modulePath
+            };
+            if (existingTaskId) {
+                const conflicting = (0, conflict_1.isConflict)(existingTaskId) ? existingTaskId.conflicting : [existingTaskId];
+                config.tasks[taskName] = {
+                    plugin,
+                    conflicting: conflicting.concat(entryPoint)
+                };
+            }
+            else {
+                config.tasks[taskName] = entryPoint;
+            }
+        }
+    }
+};
+exports.mergeTasks = mergeTasks;

package/lib/plugin/options.d.ts

@@ -0,0 +1,7 @@
+import { ValidPluginsConfig } from '@dotcom-tool-kit/config';
+import { type Plugin } from '@dotcom-tool-kit/plugin';
+import type { Logger } from 'winston';
+import { InvalidOption } from '../messages';
+export declare const validatePluginOptions: (logger: Logger, config: ValidPluginsConfig) => InvalidOption[];
+export declare const substituteOptionTags: (plugin: Plugin, config: ValidPluginsConfig) => void;
+//# sourceMappingURL=options.d.ts.map

package/lib/plugin/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../../src/plugin/options.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAE5D,OAAO,EAA4B,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAI/E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAE3C,eAAO,MAAM,qBAAqB,WAAY,MAAM,UAAU,kBAAkB,KAAG,aAAa,EAoD/F,CAAA;AAED,eAAO,MAAM,oBAAoB,WAAY,MAAM,UAAU,kBAAkB,KAAG,IAgHjF,CAAA"}

package/lib/plugin/options.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.substituteOptionTags = exports.validatePluginOptions = void 0;
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+const schemas_1 = require("@dotcom-tool-kit/schemas");
+const validated_1 = require("@dotcom-tool-kit/validated");
+const zod_1 = require("zod");
+const logger_1 = require("@dotcom-tool-kit/logger");
+const rc_file_1 = require("../rc-file");
+const validatePluginOptions = (logger, config) => {
+    const invalidOptions = [];
+    for (const [id, plugin] of Object.entries(config.plugins)) {
+        const pluginId = id;
+        const pluginOptions = config.pluginOptions[pluginId];
+        if (pluginOptions && (0, conflict_1.isConflict)(pluginOptions)) {
+            continue;
+        }
+        const pluginSchema = schemas_1.PluginSchemas[pluginId];
+        if (!pluginSchema) {
+            logger.silly(`skipping validation of ${pluginId} plugin as no schema can be found`);
+            // TODO:KB:20240412 remove legacyPluginOptions in a future major version
+            if (pluginOptions && pluginId in schemas_1.legacyPluginOptions) {
+                const movedToTask = schemas_1.legacyPluginOptions[pluginId];
+                invalidOptions.push([
+                    id,
+                    new zod_1.ZodError([
+                        {
+                            message: `options for ${logger_1.styles.plugin(id)} have moved to the ${logger_1.styles.task(movedToTask)} task`,
+                            code: zod_1.ZodIssueCode.custom,
+                            path: []
+                        }
+                    ])
+                ]);
+            }
+            continue;
+        }
+        const result = pluginSchema.safeParse(pluginOptions?.options ?? {});
+        if (result.success) {
+            // Set up options entry for plugins that don't have options specified
+            // explicitly. They could still have default options that are set by zod.
+            if (!pluginOptions) {
+                config.pluginOptions[pluginId] = {
+                    options: result.data,
+                    plugin: config.plugins['app root'],
+                    forPlugin: plugin
+                };
+            }
+            else {
+                pluginOptions.options = result.data;
+            }
+        }
+        else {
+            invalidOptions.push([id, result.error]);
+        }
+    }
+    return invalidOptions;
+};
+exports.validatePluginOptions = validatePluginOptions;
+const substituteOptionTags = (plugin, config) => {
+    // foo.bar gets the 'bar' option set for the 'foo' plugin
+    const resolveOptionPath = (optionPath) => {
+        const [pluginName, optionName] = optionPath.split('.', 2);
+        return config.pluginOptions[pluginName]?.options[optionName];
+    };
+    // throw an error if there are tags in plugin option fields to avoid circular
+    // references
+    const validateTagPath = (path) => {
+        if (path[0] === 'options' && path[1] === 'plugins') {
+            return `YAML tag referencing options used at path '${path.join('.')}'`;
+        }
+    };
+    // recursively walk through the parsed config, searching for the tag
+    // identifiers we've inserted during parsing, and substitute them for
+    // resolved option values
+    const deeplySubstitute = (node, path) => {
+        if (Array.isArray(node)) {
+            return (0, validated_1.reduceValidated)(node.map((item, i) => deeplySubstitute(item, [...path, i])));
+        }
+        else if (node && typeof node === 'object') {
+            const entries = Object.entries(node);
+            const substituted = [];
+            for (const entry of entries) {
+                const subbedEntry = (0, validated_1.reduceValidated)(
+                // allow both keys and (string) values to be substituted by options
+                entry.map((val) => {
+                    if (typeof val === 'string' && val.startsWith(rc_file_1.toolKitOptionIdent)) {
+                        // check the tag path each time so that we can have a separate
+                        // error for each incorrect use of the tag
+                        const validationError = validateTagPath([...path, entry[0]]);
+                        if (validationError) {
+                            return (0, validated_1.invalid)([validationError]);
+                        }
+                        else {
+                            // the option path is concatenated after the !toolkit/option
+                            // identifier
+                            const optionPath = val.slice(rc_file_1.toolKitOptionIdent.length);
+                            const resolvedOption = resolveOptionPath(optionPath);
+                            if (typeof resolvedOption === 'string') {
+                                return (0, validated_1.valid)(resolvedOption);
+                            }
+                            else {
+                                return (0, validated_1.invalid)([
+                                    `Option '${optionPath}' referenced at path '${path.join('.')}' does not resolve to a string (resolved to ${resolvedOption})`
+                                ]);
+                            }
+                        }
+                    }
+                    else {
+                        return (0, validated_1.valid)(val);
+                    }
+                }));
+                if (!subbedEntry.valid) {
+                    /* eslint-disable-next-line @typescript-eslint/no-explicit-any --
+                     * Invalid objects don't need to match the inner type
+                     **/
+                    substituted.push(subbedEntry);
+                    continue;
+                }
+                const [key, value] = subbedEntry.value;
+                if (key.startsWith(rc_file_1.toolKitIfDefinedIdent)) {
+                    const validationError = validateTagPath(path);
+                    if (validationError) {
+                        substituted.push((0, validated_1.invalid)([validationError]));
+                    }
+                    // the option path is concatenated after the !toolkit/if-defined
+                    // identifier
+                    const optionPath = key.slice(rc_file_1.toolKitIfDefinedIdent.length);
+                    const optionValue = resolveOptionPath(optionPath);
+                    // keep walking the path if we've found an error here so we can
+                    // gather even more errors to show the user. else skip traversal if
+                    // we aren't going to include the node
+                    if (optionValue || validationError) {
+                        const subbedValues = deeplySubstitute(value, path);
+                        if (subbedValues.valid) {
+                            substituted.push(...Object.entries(subbedValues.value).map((v) => (0, validated_1.valid)(v)));
+                        }
+                        else {
+                            /* eslint-disable-next-line @typescript-eslint/no-explicit-any --
+                             * Invalid objects don't need to match the inner type
+                             **/
+                            substituted.push(subbedValues);
+                        }
+                    }
+                }
+                else {
+                    substituted.push(deeplySubstitute(value, [...path, key]).map((subbedValue) => [key, subbedValue]));
+                }
+            }
+            return (0, validated_1.reduceValidated)(substituted).map(Object.fromEntries);
+        }
+        else {
+            return (0, validated_1.valid)(node);
+        }
+    };
+    // avoid running substitution over a config repeatedly – all substitutions
+    // will have been made in the first pass
+    if (config.resolutionTrackers.substitutedPlugins.has(plugin.id)) {
+        return;
+    }
+    if (plugin.children) {
+        for (const child of plugin.children) {
+            (0, exports.substituteOptionTags)(child, config);
+        }
+    }
+    if (plugin.rcFile) {
+        plugin.rcFile = deeplySubstitute(plugin.rcFile, []).unwrap('cannot reference plugin options when specifying options');
+    }
+    config.resolutionTrackers.substitutedPlugins.add(plugin.id);
+};
+exports.substituteOptionTags = substituteOptionTags;

package/lib/plugin/reduce-installations.d.ts

@@ -0,0 +1,7 @@
+import type { Logger } from 'winston';
+import type { HookClass, HookInstallation } from '@dotcom-tool-kit/base';
+import type { Plugin } from '@dotcom-tool-kit/plugin';
+import type { ValidConfig } from '@dotcom-tool-kit/config';
+import { Conflict } from '@dotcom-tool-kit/conflict';
+export declare function reducePluginHookInstallations(logger: Logger, config: ValidConfig, hookClasses: Record<string, HookClass>, plugin: Plugin): Promise<(HookInstallation | Conflict<HookInstallation>)[]>;
+//# sourceMappingURL=reduce-installations.d.ts.map

package/lib/plugin/reduce-installations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reduce-installations.d.ts","sourceRoot":"","sources":["../../src/plugin/reduce-installations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAE1D,OAAO,EAAE,QAAQ,EAAc,MAAM,2BAA2B,CAAA;AAgChE,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,WAAW,EACnB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,EACtC,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,gBAAgB,GAAG,QAAQ,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAwC5D"}

package/lib/plugin/reduce-installations.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducePluginHookInstallations = void 0;
+const schemas_1 = require("@dotcom-tool-kit/schemas");
+const conflict_1 = require("@dotcom-tool-kit/conflict");
+const lodash_1 = require("lodash");
+const extractForHook = (installation) => (0, conflict_1.isConflict)(installation) ? installation.conflicting[0].forHook : installation.forHook;
+// this function recursively collects all the hook installation requests from all plugins,
+// and merges them into a single, flat array of HookInstallation objects and/or Conflicts.
+//
+// it works depth-first (i.e. recurses into child plugins first), and considers how to
+// merge options or create conflicts in two stages: 1) when considering all installations
+// from child plugins, and 2) when considering how a parent plugin would override its
+// children. these steps are separate as a particular parent might not provide an override
+// for all its children, and different hooks could expect different ways of resolving
+// conflicts.
+//
+// the actual logic for this is delegated to static methods on Hook classes,
+// `Hook.mergeChildInstallations` and `Hook.overrideChildInstallations`, so separate hooks
+// can provide different logic for these steps.
+//
+// the default logic in the base Hook class is to always consider multiple installations
+// from child plugins as a conflict, and always consider a installation in a parent as
+// completely replacing any installations from children.
+//
+// for example, for a plugin `p` that depends on children `a`, `b`, and `c` that all provide
+// configuration for the `PackageJson` hook, this function will:
+//   - do all this logic for `a`, `b`, and `c`
+//   - call `Hook.mergeChildInstallations` with the appropriate concrete Hook class, and
+//     the resulting installations and/or conflicts from `a`, `b`, and `c`
+//   - call `Hook.overrideChildInstallations` with the appropriate concrete Hook class, and
+//     the resulting installations and/or conflicts from `Hook.mergeChildInstallations` and `p`
+async function reducePluginHookInstallations(logger, config, hookClasses, plugin) {
+    if (!plugin.rcFile || config.resolutionTrackers.reducedInstallationPlugins.has(plugin.id)) {
+        return [];
+    }
+    config.resolutionTrackers.reducedInstallationPlugins.add(plugin.id);
+    const rawChildInstallations = await Promise.all((plugin.children ?? []).map((child) => reducePluginHookInstallations(logger, config, hookClasses, child))).then((installations) => installations.flat());
+    const childInstallations = Object.entries((0, lodash_1.groupBy)(rawChildInstallations, extractForHook)).flatMap(([forHook, installations]) => {
+        const hookClass = hookClasses[forHook];
+        return hookClass.mergeChildInstallations(plugin, installations);
+    });
+    if (plugin.rcFile.options.hooks.length === 0) {
+        return childInstallations;
+    }
+    return plugin.rcFile.options.hooks.flatMap((hookEntry) => Object.entries(hookEntry).flatMap(([id, configHookOptions]) => {
+        const hookClass = hookClasses[id];
+        const parsedOptions = schemas_1.HookSchemas[id].parse(configHookOptions);
+        const installation = {
+            options: parsedOptions,
+            plugin,
+            forHook: id,
+            hookConstructor: hookClass
+        };
+        const childInstallationsForHook = childInstallations.filter((childInstallation) => id === extractForHook(childInstallation));
+        return hookClass.overrideChildInstallations(plugin, installation, childInstallationsForHook);
+    }));
+}
+exports.reducePluginHookInstallations = reducePluginHookInstallations;

package/lib/plugin.d.ts

@@ -1,7 +1,8 @@
-import { Plugin, PluginModule, Validated } from '@dotcom-tool-kit/types';
+import { type Plugin } from '@dotcom-tool-kit/plugin';
+import type { RawConfig, ValidPluginsConfig } from '@dotcom-tool-kit/config';
+import { Validated } from '@dotcom-tool-kit/validated';
 import type { Logger } from 'winston';
-import { RawConfig, ValidPluginsConfig } from './config';
-export declare function validatePlugin(plugin: unknown): Validated<PluginModule>;
 export declare function loadPlugin(id: string, config: RawConfig, logger: Logger, parent?: Plugin): Promise<Validated<Plugin>>;
+export declare function resolvePluginOptions(plugin: Plugin, config: ValidPluginsConfig): void;
 export declare function resolvePlugin(plugin: Plugin, config: ValidPluginsConfig, logger: Logger): void;
 //# sourceMappingURL=plugin.d.ts.map

package/lib/plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,MAAM,EACN,YAAY,EAIZ,SAAS,EACV,MAAM,wBAAwB,CAAA;AAG/B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AACrC,OAAO,EAAiB,SAAS,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAmBvE,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,YAAY,CAAC,CAgDvE;AAoBD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CA8D5B;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAyI9F"}
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAC9E,OAAO,KAAK,EAAE,SAAS,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAC5E,OAAO,EAAmC,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAEvF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAA;AAUrC,wBAAsB,UAAU,CAC9B,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAmD5B;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAiBrF;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAqB9F"}