@testforgejs/vue-test-core 1.0.0-beta.0

package/dist/index.cjs

@@ -0,0 +1,864 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Types: () => Types,
+  captureInstance: () => captureInstance,
+  createPluginInstance: () => createPluginInstance,
+  createTestFramework: () => createTestFramework,
+  createVuePlugin: () => createVuePlugin,
+  validatePreset: () => validatePreset,
+  validatePresets: () => validatePresets
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/utils/mergeComponentData.ts
+function mergeComponentData({
+  defaultMountData = {},
+  defaultData = {},
+  mountData = {},
+  directData = {},
+  skipDefault = false,
+  skipOptions = false
+}) {
+  const level1 = skipDefault ? {} : {
+    ...!skipOptions ? defaultMountData : {},
+    ...defaultData
+  };
+  const level2 = {
+    ...mountData,
+    ...directData
+  };
+  return { ...level1, ...level2 };
+}
+
+// src/constants/constants.ts
+var FRAMEWORK_NAME = "TestForge";
+var ERROR_PREFIX = `[${FRAMEWORK_NAME}]`;
+var DEFAULT_PRESET_NAME = "default";
+
+// src/validators/validatePreset.ts
+function validatePreset(name, preset) {
+  if (!preset) {
+    throw new Error(`${ERROR_PREFIX} Preset "${name}" is null or undefined.`);
+  }
+  if (!Array.isArray(preset.manifest)) {
+    throw new Error(`${ERROR_PREFIX} Preset "${name}" must have a "manifest" array.`);
+  }
+  const manifestPluginNames = /* @__PURE__ */ new Set();
+  preset.manifest.forEach((entry, index) => {
+    const { module: module2, enabled } = entry;
+    if (!module2 || typeof module2.getName !== "function") {
+      throw new Error(`${ERROR_PREFIX} Invalid module at manifest[${index}] in preset "${name}".`);
+    }
+    const pluginName = module2.getName();
+    if (manifestPluginNames.has(pluginName)) {
+      throw new Error(
+        `${ERROR_PREFIX} Duplicate plugin "${pluginName}" in manifest of preset "${name}".`
+      );
+    }
+    if (typeof enabled !== "boolean") {
+      throw new Error(
+        `${ERROR_PREFIX} Plugin "${pluginName}" in preset "${name}" must have a boolean "enabled" flag.`
+      );
+    }
+    manifestPluginNames.add(pluginName);
+  });
+  if (preset.defaults) {
+    const defaultKeys = Object.keys(preset.defaults);
+    defaultKeys.forEach((key) => {
+      if (!manifestPluginNames.has(key)) {
+        throw new Error(
+          `${ERROR_PREFIX} Preset "${name}" contains defaults for unknown plugin "${key}". This plugin is not present in the manifest.`
+        );
+      }
+      const value = preset.defaults[key];
+      const isObject = value !== null && typeof value === "object" && !Array.isArray(value);
+      if (!isObject) {
+        throw new Error(
+          `${ERROR_PREFIX} Invalid default configuration for plugin "${key}" in preset "${name}". Expected Object, but received ${typeof value}.`
+        );
+      }
+    });
+  }
+}
+
+// src/utils/getActivePreset.ts
+function getActivePreset(presets = {}, extraOptions) {
+  const requestedPresetName = extraOptions?.preset?.trim();
+  const activeName = requestedPresetName || DEFAULT_PRESET_NAME;
+  const preset = presets[activeName];
+  if (requestedPresetName && !preset) {
+    throw new Error(
+      `[withPreset] Requested preset "${requestedPresetName}" not found in available presets.`
+    );
+  }
+  if (preset) {
+    validatePreset(activeName, preset);
+  }
+  return preset;
+}
+
+// src/utils/getPresetManifest.ts
+function getPresetManifest(preset) {
+  return preset?.manifest ?? [];
+}
+
+// src/utils/createSupportedPluginsState.ts
+function createSupportedPluginsState(preset) {
+  const map = {};
+  for (const { module: module2, enabled } of getPresetManifest(preset)) {
+    if (typeof enabled !== "boolean") {
+      throw new Error(
+        `[TestForge] Plugin "${module2.getName()}" has invalid "enabled" value: ${String(enabled)}. Expected boolean.`
+      );
+    }
+    map[module2.getName()] = enabled;
+  }
+  return map;
+}
+
+// src/pipeline/core/createPipelineContext.ts
+function createPipelineContext(params) {
+  const { defaultMountOptions = {}, mountOptions = {}, extraOptions = {}, presets = {} } = params;
+  const activePreset = getActivePreset(presets, extraOptions);
+  const supportedPlugins = createSupportedPluginsState(activePreset);
+  return {
+    defaultMountOptions,
+    mountOptions,
+    extraOptions,
+    supportedPlugins,
+    preset: activePreset,
+    result: {
+      mountOptions: {},
+      global: {},
+      pluginDefaultsState: {},
+      plugins: {}
+    }
+  };
+}
+
+// src/pipeline/core/runPipeline.ts
+function runPipeline(ctx, middlewares) {
+  let context = ctx;
+  for (const middleware of middlewares) {
+    const result = middleware(context);
+    if (result) {
+      context = result;
+    }
+  }
+  return context;
+}
+
+// src/pipeline/core/createPipeline.ts
+function createPipeline(middlewares) {
+  return {
+    /*
+     * Runs the middleware chain sequentially.
+     */
+    run(ctx) {
+      return runPipeline(ctx, middlewares);
+    }
+  };
+}
+
+// src/pipeline/middleware/typeGuards/assertIsObject.ts
+function assertIsObject(val, name) {
+  if (val !== null && typeof val === "object" && !Array.isArray(val)) return;
+  throw new Error(
+    `${ERROR_PREFIX} Critical error: "${name}" must be an Object. Received ${Array.isArray(val) ? "array" : typeof val} (${val}).`
+  );
+}
+
+// src/pipeline/middleware/validation/assertConfigurationShape.ts
+var assertConfigurationShape = (ctx) => {
+  assertIsObject(ctx.defaultMountOptions, "defaultMountOptions");
+  assertIsObject(ctx.mountOptions, "mountOptions");
+  assertIsObject(ctx.extraOptions, "extraOptions");
+  return ctx;
+};
+
+// src/pipeline/plugins/logic/resolveExtraOptions.ts
+function resolveExtraOptions(extraOptions) {
+  return extraOptions;
+}
+
+// src/pipeline/middleware/validation/validators/assertUnsupportedPlugins.ts
+var assertUnsupportedPlugins = (plugins, supported) => {
+  for (const name of Object.keys(plugins)) {
+    if (!supported.has(name)) {
+      throw new Error(
+        `${ERROR_PREFIX} Plugin "${name}" is configured but not supported by the active preset.`
+      );
+    }
+  }
+};
+
+// src/pipeline/middleware/validation/validators/assertExtraOptionUnsupportedPlugins.ts
+var assertExtraOptionUnsupportedPlugins = (extraOptions, supported) => {
+  assertUnsupportedPlugins(extraOptions.plugins ?? {}, supported);
+};
+
+// src/pipeline/middleware/typeGuards/assertPluginValue.ts
+function assertPluginValue(val, name, source) {
+  const isObject = val !== null && typeof val === "object" && !Array.isArray(val);
+  const isValid = val === void 0 || val === false || isObject;
+  if (!isValid) {
+    throw new Error(
+      `${ERROR_PREFIX} Invalid configuration for plugin "${name}" in ${source}. Expected Object or Boolean (false), but received ${typeof val} (${val}).`
+    );
+  }
+}
+
+// src/pipeline/middleware/validation/validators/assertResolvedPluginValues.ts
+var assertResolvedPluginValues = (plugins) => {
+  for (const [name, value] of Object.entries(plugins)) {
+    assertPluginValue(value, name, "plugins");
+  }
+};
+
+// src/pipeline/middleware/validation/validators/assertExtraOptionPluginValues.ts
+var assertExtraOptionPluginValues = (extraOptions, supported) => {
+  const plugins = extraOptions.plugins ?? {};
+  for (const name of supported) {
+    if (Object.prototype.hasOwnProperty.call(plugins, name)) {
+      assertPluginValue(plugins[name], name, "extraOptions");
+    }
+  }
+};
+
+// src/pipeline/middleware/validation/assertPluginOptions.ts
+var assertPluginOptions = (ctx) => {
+  const { supportedPlugins, extraOptions } = ctx;
+  const { plugins } = ctx.result;
+  const supported = new Set(Object.keys(supportedPlugins));
+  assertUnsupportedPlugins(plugins || {}, supported);
+  assertExtraOptionUnsupportedPlugins(resolveExtraOptions(extraOptions), supported);
+  assertResolvedPluginValues(plugins);
+  assertExtraOptionPluginValues(resolveExtraOptions(extraOptions), supported);
+  return ctx;
+};
+
+// src/pipeline/middleware/validation/assertResultShape.ts
+function validateResult(ctx) {
+  const { result } = ctx;
+  assertIsObject(result, "result");
+  assertIsObject(result.mountOptions, "result.mountOptions");
+  assertIsObject(result.global, "result.global");
+  assertIsObject(result.plugins, "result.plugins");
+}
+var assertResultShape = (ctx) => {
+  validateResult(ctx);
+  return ctx;
+};
+var assertFinalResultShape = (ctx) => {
+  validateResult(ctx);
+  return ctx;
+};
+
+// src/pipeline/state/mergeRecord.ts
+function mergeRecord(base, patch) {
+  if (!patch) return base;
+  const result = { ...base };
+  for (const key in patch) {
+    const value = patch[key];
+    if (value !== void 0) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+// src/pipeline/state/patchResultState.ts
+function patchResultState(ctx, patch) {
+  if (patch.mountOptions) {
+    ctx.result.mountOptions = mergeRecord(ctx.result.mountOptions, patch.mountOptions);
+  }
+  if (patch.plugins) {
+    ctx.result.plugins = mergeRecord(ctx.result.plugins, patch.plugins);
+  }
+  if (patch.pluginDefaultsState) {
+    ctx.result.pluginDefaultsState = mergeRecord(
+      ctx.result.pluginDefaultsState,
+      patch.pluginDefaultsState
+    );
+  }
+  if (patch.global) {
+    ctx.result.global = mergeRecord(ctx.result.global, patch.global);
+  }
+  return ctx;
+}
+
+// src/pipeline/middleware/transformers/withBaseMountOptions.ts
+var withBaseMountOptions = (ctx) => {
+  const { defaultMountOptions, mountOptions, extraOptions } = ctx;
+  const {
+    global: _dg,
+    plugins: _dp,
+    attrs: _da,
+    props: _dpr,
+    slots: _ds,
+    ...flatDefaults
+  } = defaultMountOptions;
+  const {
+    global: _mg,
+    plugins: _mp,
+    attrs: _ma,
+    props: _mpr,
+    slots: _ms,
+    ...flatOverrides
+  } = mountOptions;
+  return patchResultState(ctx, {
+    mountOptions: extraOptions.skipDefaultOptions ? mergeRecord(flatOverrides) : mergeRecord(flatDefaults, flatOverrides)
+  });
+};
+
+// src/guards/isPlainObject.ts
+function isPlainObject(item) {
+  if (item === null || typeof item !== "object" || Array.isArray(item)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(item);
+  return prototype === Object.prototype || prototype === null;
+}
+
+// src/utils/mergeConfigs.ts
+function mergeConfigs(target, source) {
+  const arrays = Array.isArray(target) && Array.isArray(source);
+  const objects = isPlainObject(target) && isPlainObject(source);
+  if (arrays) {
+    return [.../* @__PURE__ */ new Set([...target, ...source])];
+  }
+  if (objects) {
+    const output = { ...target };
+    for (const key of Object.keys(source)) {
+      const targetValue = target[key];
+      const sourceValue = source[key];
+      if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+        output[key] = [.../* @__PURE__ */ new Set([...targetValue, ...sourceValue])];
+      } else if (isPlainObject(targetValue) && isPlainObject(sourceValue)) {
+        output[key] = mergeConfigs(targetValue, sourceValue);
+      } else {
+        output[key] = sourceValue;
+      }
+    }
+    return output;
+  }
+  throw new Error(`${ERROR_PREFIX} mergeConfigs() expects two plain objects or two arrays.`);
+}
+
+// src/pipeline/middleware/transformers/withGlobal.ts
+var withGlobal = (ctx) => {
+  const { defaultMountOptions, mountOptions, extraOptions } = ctx;
+  return patchResultState(ctx, {
+    global: mergeConfigs(
+      extraOptions.skipDefaultOptions ? {} : defaultMountOptions.global || {},
+      mountOptions.global || {}
+    )
+  });
+};
+
+// src/pipeline/middleware/transformers/withAttrs.ts
+var withAttrs = (ctx) => {
+  const { defaultMountOptions, mountOptions, extraOptions } = ctx;
+  const attrs = mergeRecord(
+    extraOptions.skipDefaultOptions ? {} : defaultMountOptions.attrs || {},
+    mountOptions.attrs || {}
+  );
+  return patchResultState(ctx, {
+    mountOptions: Object.keys(attrs).length > 0 ? { attrs } : {}
+  });
+};
+
+// src/pipeline/plugins/logic/filterSupportedPlugins.ts
+function filterSupportedPlugins(plugins = {}, supported) {
+  return Object.fromEntries(
+    Object.entries(plugins).filter(([name]) => supported[name] !== void 0)
+  );
+}
+
+// src/pipeline/middleware/transformers/withPluginsBase.ts
+var withPluginsBase = (ctx) => {
+  const { defaultMountOptions, mountOptions, extraOptions, supportedPlugins } = ctx;
+  return patchResultState(ctx, {
+    plugins: {
+      ...extraOptions.skipDefaultOptions ? {} : filterSupportedPlugins(defaultMountOptions.plugins ?? {}, supportedPlugins),
+      ...mountOptions.plugins || {}
+    }
+  });
+};
+
+// src/pipeline/middleware/transformers/withPluginsManifest.ts
+var withPluginsManifest = (ctx) => {
+  const plugins = Object.fromEntries(
+    Object.entries(ctx.supportedPlugins).map(([name, enabled]) => [name, enabled ? {} : false])
+  );
+  return patchResultState(ctx, {
+    plugins
+  });
+};
+
+// src/pipeline/middleware/transformers/withPreset.ts
+var withPreset = (ctx) => {
+  const { preset } = ctx;
+  if (!preset?.defaults) return ctx;
+  return patchResultState(ctx, {
+    pluginDefaultsState: { ...preset.defaults }
+  });
+};
+
+// src/pipeline/middleware/typeGuards/isPluginOverlayObject.ts
+function isPluginOverlayObject(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+
+// src/pipeline/plugins/logic/getExtraPluginOptions.ts
+var getExtraPluginOptions = (extraOptions, name) => {
+  return extraOptions.plugins?.[name];
+};
+
+// src/pipeline/plugins/logic/getPluginConfig.ts
+function getPluginConfig(ctx, name) {
+  const base = ctx.result.plugins[name];
+  const extraOptions = resolveExtraOptions(ctx.extraOptions);
+  const overlay = getExtraPluginOptions(extraOptions, name);
+  const isEnabled = overlay !== void 0 ? overlay !== false : base !== false && base !== void 0;
+  if (!isEnabled) {
+    return false;
+  }
+  const current = isPluginOverlayObject(base) ? base : {};
+  const extra = isPluginOverlayObject(overlay) ? overlay : {};
+  return {
+    ...current,
+    ...extra
+  };
+}
+
+// src/pipeline/plugins/logic/patchPluginState.ts
+function patchPluginState(ctx, name, config) {
+  const current = ctx.result.plugins[name];
+  const currentObj = isPluginOverlayObject(current) ? current : {};
+  return patchResultState(ctx, {
+    plugins: {
+      [name]: {
+        ...currentObj,
+        ...config
+      }
+    }
+  });
+}
+
+// src/pipeline/plugins/logic/resolveRuntimePluginState.ts
+function resolveRuntimePluginState(config, overlay) {
+  const runtimeConfig = {
+    ...config
+  };
+  if (isPluginOverlayObject(overlay)) {
+    const meta = overlay.__meta;
+    if (meta?.instance) {
+      runtimeConfig.__sharedInstance = meta.instance;
+    }
+  }
+  delete runtimeConfig.__meta;
+  return runtimeConfig;
+}
+
+// src/pipeline/plugins/adapters/createPluginMiddleware.ts
+function createPluginMiddleware(name) {
+  return (ctx) => {
+    const config = getPluginConfig(ctx, name);
+    if (!config) return ctx;
+    const extraOptions = resolveExtraOptions(ctx.extraOptions);
+    const runtimeConfig = resolveRuntimePluginState(
+      config,
+      getExtraPluginOptions(extraOptions, name)
+    );
+    return patchPluginState(ctx, name, runtimeConfig);
+  };
+}
+
+// src/pipeline/plugins/builders/createPluginsMiddlewares.ts
+function createPluginsMiddlewares(supportedPlugins) {
+  return Object.keys(supportedPlugins).map(
+    (name) => createPluginMiddleware(name)
+  );
+}
+
+// src/pipeline/plugins/logic/mergePluginDefaults.ts
+function mergePluginDefaults(ctx, name) {
+  const { result } = ctx;
+  const current = result.plugins[name];
+  if (current === false) {
+    return ctx;
+  }
+  result.plugins[name] = {
+    ...result.pluginDefaultsState[name] ?? {},
+    ...current ?? {}
+  };
+  return ctx;
+}
+
+// src/pipeline/plugins/adapters/createPluginMergeMiddleware.ts
+function createPluginMergeMiddleware(name) {
+  return (ctx) => {
+    return mergePluginDefaults(ctx, name);
+  };
+}
+
+// src/pipeline/plugins/builders/createPluginsMergeMiddlewares.ts
+function createPluginsMergeMiddlewares(supportedPlugins) {
+  return Object.keys(supportedPlugins).map(
+    (name) => createPluginMergeMiddleware(name)
+  );
+}
+
+// src/pipeline/mount/createMountPipeline.ts
+function createMountPipeline(ctx) {
+  return [
+    assertConfigurationShape,
+    assertResultShape,
+    withPreset,
+    withPluginsManifest,
+    withBaseMountOptions,
+    withGlobal,
+    withAttrs,
+    withPluginsBase,
+    assertPluginOptions,
+    ...createPluginsMiddlewares(ctx.supportedPlugins),
+    ...createPluginsMergeMiddlewares(ctx.supportedPlugins),
+    assertFinalResultShape
+  ];
+}
+
+// src/core/mountWithPlugins.ts
+var import_test_utils = require("@vue/test-utils");
+
+// src/pluginsRegistry/createPluginRegistry.ts
+function createPluginRegistry(manifest = []) {
+  const map = /* @__PURE__ */ new Map();
+  const register = (entry) => {
+    const { module: module2 } = entry;
+    if (!module2) return;
+    const name = module2.getName();
+    const definition = module2.getDefinition();
+    map.set(name, definition);
+  };
+  manifest.forEach(register);
+  return {
+    register,
+    get: (name) => map.get(name),
+    has: (name) => map.has(name),
+    entries: () => map.entries(),
+    getNames: () => Array.from(map.keys())
+  };
+}
+
+// src/pluginsRegistry/createPlugins.ts
+function createPlugins(options = {}, ctx) {
+  const plugins = [];
+  const { preset } = ctx;
+  const registry = createPluginRegistry(preset?.manifest);
+  for (const [name, definition] of registry.entries()) {
+    let pluginOptions = options[name];
+    if (pluginOptions !== false && pluginOptions && typeof pluginOptions === "object") {
+      if (definition.beforeCreate) {
+        pluginOptions = definition.beforeCreate(ctx, pluginOptions);
+      }
+      const pluginInstance = definition.create(pluginOptions);
+      if (definition.afterCreate) {
+        definition.afterCreate(pluginInstance, ctx);
+      }
+      plugins.push(pluginInstance);
+    }
+  }
+  return plugins;
+}
+
+// src/core/mountWithPlugins.ts
+function mountWithPlugins(component, ctx, overrides = {}, runtimeOptions = {
+  shallowByDefault: false
+}) {
+  const { result } = ctx;
+  const mergedOptions = {
+    ...result.mountOptions,
+    ...overrides,
+    plugins: result.plugins
+  };
+  const {
+    shallow,
+    plugins = {},
+    skipManagedPlugins = false,
+    global: overrideGlobal,
+    ...restOptions
+  } = mergedOptions;
+  const shouldUseShallow = shallow ?? runtimeOptions.shallowByDefault;
+  const mountFunction = shouldUseShallow ? import_test_utils.shallowMount : import_test_utils.mount;
+  const globalPlugins = skipManagedPlugins ? [] : createPlugins(plugins, ctx);
+  const finalGlobal = {
+    ...result.global,
+    ...overrideGlobal
+  };
+  if (globalPlugins.length > 0) {
+    finalGlobal.plugins = [...finalGlobal.plugins || [], ...globalPlugins];
+  }
+  return mountFunction(component, {
+    ...restOptions,
+    global: finalGlobal
+  });
+}
+
+// src/validators/validatePresets.ts
+function validatePresets(presets = {}) {
+  if (!isPlainObject(presets)) {
+    throw new Error(`${ERROR_PREFIX} Presets must be a plain object.`);
+  }
+  Object.entries(presets).forEach(([name, preset]) => {
+    validatePreset(name, preset);
+  });
+}
+
+// src/assertions/assertIsPlainObject.ts
+function assertIsPlainObject(value, name = "value") {
+  if (!isPlainObject(value)) {
+    throw new Error(`${name} must be a plain object.`);
+  }
+}
+
+// src/validators/validateCreateTestFrameworkOptions.ts
+function validateCreateTestFrameworkOptions(options = {}) {
+  assertIsPlainObject(options, "createTestFramework options");
+  const { shallowByDefault, presets } = options;
+  if (presets !== void 0) {
+    validatePresets(presets);
+  }
+  if (shallowByDefault !== void 0 && typeof shallowByDefault !== "boolean") {
+    throw new Error(`${ERROR_PREFIX} "shallowByDefault" must be a boolean.`);
+  }
+}
+
+// src/validators/validatePlainObjectArgument.ts
+function validatePlainObjectArgument(value, name) {
+  if (!isPlainObject(value)) {
+    throw new Error(`${ERROR_PREFIX} "${name}" must be a plain object.`);
+  }
+}
+
+// src/validators/validateBooleanOption.ts
+function validateBooleanOption(value, name) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new Error(`${ERROR_PREFIX} "${name}" must be a boolean.`);
+  }
+}
+
+// src/utils/getSupportedPluginNames.ts
+function getSupportedPluginNames(presets = {}, extraOptions) {
+  const activePreset = getActivePreset(presets, extraOptions);
+  return getPresetManifest(activePreset).map((entry) => entry.module.getName());
+}
+
+// src/utils/warnRootPluginOption.ts
+function warnRootPluginOption(pluginName, context) {
+  console.warn(
+    [
+      `${ERROR_PREFIX} Detected plugin option "${pluginName}" at the root of "${context}".`,
+      "",
+      "Plugin options must be placed under:",
+      "",
+      "{",
+      "  plugins: {",
+      `    ${pluginName}: { ... }`,
+      "  }",
+      "}",
+      "",
+      `Did you mean to use "${context}.plugins.${pluginName}"?`
+    ].join("\n")
+  );
+}
+
+// src/validators/warnRootPluginOptions.ts
+function warnRootPluginOptions(options, context, presets = {}, extraOptions) {
+  const pluginNames = getSupportedPluginNames(presets, extraOptions);
+  pluginNames.forEach((pluginName) => {
+    const pluginAlreadyConfigured = options.plugins && pluginName in options.plugins;
+    if (Object.hasOwn(options, pluginName) && !pluginAlreadyConfigured) {
+      warnRootPluginOption(pluginName, context);
+    }
+  });
+}
+
+// src/validators/validateComponentFactoryOptions.ts
+function validateComponentFactoryOptions(options, context, presets = {}, extraOptions) {
+  validatePlainObjectArgument(options, context);
+  validateBooleanOption(options.skipManagedPlugins, "skipManagedPlugins");
+  warnRootPluginOptions(options, context, presets, extraOptions);
+}
+
+// src/validators/validateTestComponentFactoryArguments.ts
+function validateTestComponentFactoryArguments(component, defaultProps, defaultMountOptions, defaultSlots, presets) {
+  const isComponent = component !== null && (typeof component === "object" || typeof component === "function");
+  if (!isComponent) {
+    throw new Error(`${ERROR_PREFIX} testComponentFactory() requires a valid Vue component.`);
+  }
+  validatePlainObjectArgument(defaultProps, "defaultProps");
+  validateComponentFactoryOptions(
+    defaultMountOptions,
+    "defaultMountOptions",
+    presets
+  );
+  validatePlainObjectArgument(defaultSlots, "defaultSlots");
+}
+
+// src/validators/validateComponentFactoryExtraOptions.ts
+function validateComponentFactoryExtraOptions(options, presets = {}) {
+  validatePlainObjectArgument(options, "extraOptions");
+  validateBooleanOption(options.skipDefaultProps, "skipDefaultProps");
+  validateBooleanOption(options.skipDefaultSlots, "skipDefaultSlots");
+  validateBooleanOption(options.skipDefaultOptions, "skipDefaultOptions");
+  warnRootPluginOptions(options, "extraOptions", presets, options);
+}
+
+// src/validators/validateComponentFactoryArguments.ts
+function validateComponentFactoryArguments(props, mountOptions, slots, extraOptions, presets = {}) {
+  validatePlainObjectArgument(props, "props");
+  validateComponentFactoryOptions(
+    mountOptions,
+    "mountOptions",
+    presets,
+    extraOptions
+  );
+  validatePlainObjectArgument(slots, "slots");
+  validateComponentFactoryExtraOptions(extraOptions, presets);
+}
+
+// src/core/createTestFramework.ts
+function createTestFramework(options = {}) {
+  validateCreateTestFrameworkOptions(options);
+  const { presets = {}, shallowByDefault = false } = options;
+  const testComponentFactory = (component, defaultProps = {}, defaultMountOptions = {}, defaultSlots = {}) => {
+    validateTestComponentFactoryArguments(
+      component,
+      defaultProps,
+      defaultMountOptions,
+      defaultSlots,
+      presets
+    );
+    return (props = {}, mountOptions = {}, slots = {}, extraOptions = {}) => {
+      validateComponentFactoryArguments(props, mountOptions, slots, extraOptions, presets);
+      const {
+        skipDefaultProps = false,
+        skipDefaultSlots = false,
+        skipDefaultOptions = false
+      } = extraOptions;
+      const finalProps = mergeComponentData({
+        defaultMountData: defaultMountOptions.props,
+        defaultData: defaultProps,
+        mountData: mountOptions.props,
+        directData: props,
+        skipDefault: skipDefaultProps,
+        skipOptions: skipDefaultOptions
+      });
+      const finalSlots = mergeComponentData({
+        defaultMountData: defaultMountOptions.slots,
+        defaultData: defaultSlots,
+        mountData: mountOptions.slots,
+        directData: slots,
+        skipDefault: skipDefaultSlots,
+        skipOptions: skipDefaultOptions
+      });
+      const ctx = createPipelineContext({
+        defaultMountOptions,
+        mountOptions,
+        extraOptions,
+        presets
+      });
+      const pipeline = createPipeline(createMountPipeline(ctx));
+      const readyCtx = pipeline.run(ctx);
+      const mountRuntimeOptions = {
+        shallowByDefault
+      };
+      return mountWithPlugins(
+        component,
+        readyCtx,
+        {
+          props: finalProps,
+          slots: finalSlots
+        },
+        mountRuntimeOptions
+      );
+    };
+  };
+  return { testComponentFactory };
+}
+
+// src/pluginsRegistry/helpers/exposeInstance.ts
+function exposeInstance(instance, options) {
+  if (typeof options?.expose === "function") {
+    options.expose(instance);
+  }
+}
+
+// src/pluginsRegistry/factory/createPluginInstance.ts
+function createPluginInstance(factory, options) {
+  const instance = options.__sharedInstance ?? factory(options);
+  exposeInstance(instance, options);
+  return instance;
+}
+
+// src/pluginsRegistry/factory/createVuePlugin.ts
+function createVuePlugin(plugin, options) {
+  if (options.__sharedInstance) {
+    throw new Error(
+      `${ERROR_PREFIX} __sharedInstance is not supported for non-instance Vue plugins. Shared instances are only supported for stateful plugin factories such as Router, Pinia or vue-i18n.`
+    );
+  }
+  if (options.expose) {
+    throw new Error(
+      `${ERROR_PREFIX} expose() is not supported for non-instance Vue plugins because they do not produce a runtime instance. The expose callback is only available for stateful plugin factories such as Router, Pinia or vue-i18n.`
+    );
+  }
+  return [plugin, options];
+}
+
+// src/utils/captureInstance.ts
+function captureInstance() {
+  let instance;
+  return {
+    expose(ins) {
+      instance = ins;
+    },
+    get instance() {
+      return instance;
+    }
+  };
+}
+
+// src/index.ts
+var Types = {};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Types,
+  captureInstance,
+  createPluginInstance,
+  createTestFramework,
+  createVuePlugin,
+  validatePreset,
+  validatePresets
+});