@html-validate/vitest-config 0.0.0 → 1.0.0

package/README.md

@@ -1,45 +1,41 @@
 # @html-validate/vitest-config
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+> Vitest shareable preset used by the various HTML-validate packages
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+## Installation
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+Install Vitest and this preset:
 
-## Purpose
+```bash
+npm install --save-dev vitest @html-validate/vitest-config
+```
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@html-validate/vitest-config`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+## Usage
 
-## What is OIDC Trusted Publishing?
+`vite.config.mts` (or `vitest.config.mts`):
 
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
+```diff
+ import { defineConfig } from "vitest/config";
++import { defineTestConfig } from "@html-validate/vitest-config";
 
-## Setup Instructions
+ export default defineConfig({
++    test: defineTestConfig(),
+ });
+```
 
-To properly configure OIDC trusted publishing for this package:
+### Override defaults
 
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
+You can pass your own config to `defineTestConfig` to override defaults:
 
-## DO NOT USE THIS PACKAGE
+`vite.config.mts`
 
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
+```diff
+ import { defineConfig } from "vitest/config";
+ import { defineTestConfig } from "@html-validate/vitest-config";
 
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+ export default defineConfig({
+     test: defineTestConfig({
++        environment: "jsdom",
+     }),
+ });
+```

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { type TestUserConfig } from "vitest/config";
+export declare function defineTestConfig(userConfig?: TestUserConfig): TestUserConfig;

package/dist/index.js

@@ -0,0 +1,397 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod2) => function __require() {
+  try {
+    return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
+  } catch (e2) {
+    throw mod2 = 0, e2;
+  }
+};
+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 __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+
+// node_modules/deepmerge/dist/cjs.js
+var require_cjs = __commonJS({
+  "node_modules/deepmerge/dist/cjs.js"(exports, module) {
+    "use strict";
+    var isMergeableObject = function isMergeableObject2(value) {
+      return isNonNullObject(value) && !isSpecial(value);
+    };
+    function isNonNullObject(value) {
+      return !!value && typeof value === "object";
+    }
+    function isSpecial(value) {
+      var stringValue = Object.prototype.toString.call(value);
+      return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+    }
+    var canUseSymbol = typeof Symbol === "function" && Symbol.for;
+    var REACT_ELEMENT_TYPE = canUseSymbol ? /* @__PURE__ */ Symbol.for("react.element") : 60103;
+    function isReactElement(value) {
+      return value.$$typeof === REACT_ELEMENT_TYPE;
+    }
+    function emptyTarget(val) {
+      return Array.isArray(val) ? [] : {};
+    }
+    function cloneUnlessOtherwiseSpecified(value, options) {
+      return options.clone !== false && options.isMergeableObject(value) ? deepmerge2(emptyTarget(value), value, options) : value;
+    }
+    function defaultArrayMerge(target, source, options) {
+      return target.concat(source).map(function(element) {
+        return cloneUnlessOtherwiseSpecified(element, options);
+      });
+    }
+    function getMergeFunction(key, options) {
+      if (!options.customMerge) {
+        return deepmerge2;
+      }
+      var customMerge = options.customMerge(key);
+      return typeof customMerge === "function" ? customMerge : deepmerge2;
+    }
+    function getEnumerableOwnPropertySymbols(target) {
+      return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+        return Object.propertyIsEnumerable.call(target, symbol);
+      }) : [];
+    }
+    function getKeys(target) {
+      return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+    }
+    function propertyIsOnObject(object, property) {
+      try {
+        return property in object;
+      } catch (_2) {
+        return false;
+      }
+    }
+    function propertyIsUnsafe(target, key) {
+      return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+    }
+    function mergeObject(target, source, options) {
+      var destination = {};
+      if (options.isMergeableObject(target)) {
+        getKeys(target).forEach(function(key) {
+          destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+        });
+      }
+      getKeys(source).forEach(function(key) {
+        if (propertyIsUnsafe(target, key)) {
+          return;
+        }
+        if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
+          destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+        } else {
+          destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+        }
+      });
+      return destination;
+    }
+    function deepmerge2(target, source, options) {
+      options = options || {};
+      options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+      options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+      options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+      var sourceIsArray = Array.isArray(source);
+      var targetIsArray = Array.isArray(target);
+      var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
+      if (!sourceAndTargetTypesMatch) {
+        return cloneUnlessOtherwiseSpecified(source, options);
+      } else if (sourceIsArray) {
+        return options.arrayMerge(target, source, options);
+      } else {
+        return mergeObject(target, source, options);
+      }
+    }
+    deepmerge2.all = function deepmergeAll(array, options) {
+      if (!Array.isArray(array)) {
+        throw new Error("first argument should be an array");
+      }
+      return array.reduce(function(prev, next) {
+        return deepmerge2(prev, next, options);
+      }, {});
+    };
+    var deepmerge_1 = deepmerge2;
+    module.exports = deepmerge_1;
+  }
+});
+
+// node_modules/@vitest/coverage-v8/dist/index.js
+import inspector from "node:inspector/promises";
+import { fileURLToPath } from "node:url";
+
+// node_modules/std-env/dist/index.mjs
+var e = globalThis.process?.env || /* @__PURE__ */ Object.create(null);
+var t = globalThis.process || { env: e };
+var n = t !== void 0 && t.env && t.env.NODE_ENV || void 0;
+var r = [[`claude`, [`CLAUDECODE`, `CLAUDE_CODE`]], [`replit`, [`REPL_ID`]], [`gemini`, [`GEMINI_CLI`]], [`codex`, [`CODEX_SANDBOX`, `CODEX_THREAD_ID`]], [`opencode`, [`OPENCODE`]], [`pi`, [i(`PATH`, /\.pi[\\/]agent/)]], [`auggie`, [`AUGMENT_AGENT`]], [`goose`, [`GOOSE_PROVIDER`]], [`junie`, [`JUNIE_DATA`, `JUNIE_SHIM_PATH`]], [`devin`, [i(`EDITOR`, /devin/)]], [`cursor`, [`CURSOR_AGENT`]], [`kiro`, [i(`TERM_PROGRAM`, /kiro/, { noTTY: true })]]];
+function i(n2, r2, i2) {
+  return () => {
+    if (i2?.noTTY && t.stdout?.isTTY) return false;
+    let a2 = e[n2];
+    return a2 ? r2.test(a2) : false;
+  };
+}
+function a() {
+  let t2 = e.AI_AGENT;
+  if (t2) return { name: t2.toLowerCase() };
+  for (let [t3, n2] of r) for (let r2 of n2) if (typeof r2 == `string` ? e[r2] : r2()) return { name: t3 };
+  return {};
+}
+var o = a();
+var s = o.name;
+var c = !!o.name;
+var l = [[`APPVEYOR`], [`AWS_AMPLIFY`, `AWS_APP_ID`, { ci: true }], [`AZURE_PIPELINES`, `SYSTEM_TEAMFOUNDATIONCOLLECTIONURI`], [`AZURE_STATIC`, `INPUT_AZURE_STATIC_WEB_APPS_API_TOKEN`], [`APPCIRCLE`, `AC_APPCIRCLE`], [`BAMBOO`, `bamboo_planKey`], [`BITBUCKET`, `BITBUCKET_COMMIT`], [`BITRISE`, `BITRISE_IO`], [`BUDDY`, `BUDDY_WORKSPACE_ID`], [`BUILDKITE`], [`CIRCLE`, `CIRCLECI`], [`CIRRUS`, `CIRRUS_CI`], [`CLOUDFLARE_PAGES`, `CF_PAGES`, { ci: true }], [`CLOUDFLARE_WORKERS`, `WORKERS_CI`, { ci: true }], [`GOOGLE_CLOUDRUN`, `K_SERVICE`], [`GOOGLE_CLOUDRUN_JOB`, `CLOUD_RUN_JOB`], [`CODEBUILD`, `CODEBUILD_BUILD_ARN`], [`CODEFRESH`, `CF_BUILD_ID`], [`DRONE`], [`DRONE`, `DRONE_BUILD_EVENT`], [`DSARI`], [`GITHUB_ACTIONS`], [`GITLAB`, `GITLAB_CI`], [`GITLAB`, `CI_MERGE_REQUEST_ID`], [`GOCD`, `GO_PIPELINE_LABEL`], [`LAYERCI`], [`JENKINS`, `JENKINS_URL`], [`HUDSON`, `HUDSON_URL`], [`MAGNUM`], [`NETLIFY`], [`NETLIFY`, `NETLIFY_LOCAL`, { ci: false }], [`NEVERCODE`], [`RENDER`], [`SAIL`, `SAILCI`], [`SEMAPHORE`], [`SCREWDRIVER`], [`SHIPPABLE`], [`SOLANO`, `TDDIUM`], [`STRIDER`], [`TEAMCITY`, `TEAMCITY_VERSION`], [`TRAVIS`], [`VERCEL`, `NOW_BUILDER`], [`VERCEL`, `VERCEL`, { ci: false }], [`VERCEL`, `VERCEL_ENV`, { ci: false }], [`APPCENTER`, `APPCENTER_BUILD_ID`], [`CODESANDBOX`, `CODESANDBOX_SSE`, { ci: false }], [`CODESANDBOX`, `CODESANDBOX_HOST`, { ci: false }], [`STACKBLITZ`], [`STORMKIT`], [`CLEAVR`], [`ZEABUR`], [`CODESPHERE`, `CODESPHERE_APP_ID`, { ci: true }], [`RAILWAY`, `RAILWAY_PROJECT_ID`], [`RAILWAY`, `RAILWAY_SERVICE_ID`], [`DENO-DEPLOY`, `DENO_DEPLOY`], [`DENO-DEPLOY`, `DENO_DEPLOYMENT_ID`], [`FIREBASE_APP_HOSTING`, `FIREBASE_APP_HOSTING`, { ci: true }], [`EDGEONE_PAGES`, `EO_PAGES_CI`, { ci: true }]];
+function u() {
+  for (let t2 of l) if (e[t2[1] || t2[0]]) return { name: t2[0].toLowerCase(), ...t2[2] };
+  return e.SHELL === `/bin/jsh` && t.versions?.webcontainer ? { name: `stackblitz`, ci: false } : { name: ``, ci: false };
+}
+var d = u();
+var f = d.name;
+var p = t.platform || ``;
+var m = !!e.CI || d.ci !== false;
+var h = !!t.stdout?.isTTY;
+var _ = !!e.DEBUG;
+var v = n === `test` || !!e.TEST;
+var y = n === `production` || e.MODE === `production`;
+var b = n === `dev` || n === `development` || e.MODE === `development`;
+var x = !!e.MINIMAL || m || v || !h;
+var S = /^win/i.test(p);
+var C = /^linux/i.test(p);
+var w = /^darwin/i.test(p);
+var T = !e.NO_COLOR && (!!e.FORCE_COLOR || (h || S) && e.TERM !== `dumb` || m);
+var E = (t.versions?.node || ``).replace(/^v/, ``) || null;
+var D = Number(E?.split(`.`)[0]) || null;
+var O = !!t?.versions?.node;
+var k = `Bun` in globalThis;
+var A = `Deno` in globalThis;
+var j = `fastly` in globalThis;
+var M = `Netlify` in globalThis;
+var N = `EdgeRuntime` in globalThis;
+var P = globalThis.navigator?.userAgent === `Cloudflare-Workers`;
+var F = [[M, `netlify`], [N, `edge-light`], [P, `workerd`], [j, `fastly`], [A, `deno`], [k, `bun`], [O, `node`]];
+function I() {
+  let e2 = F.find((e3) => e3[0]);
+  if (e2) return { name: e2[1] };
+}
+var L = I();
+var R = L?.name || ``;
+
+// node_modules/@vitest/coverage-v8/dist/load-provider-CdgAx3rL.js
+var name = "./provider.js";
+async function loadProvider() {
+  const { V8CoverageProvider } = await import(
+    /* @vite-ignore */
+    name
+  );
+  return new V8CoverageProvider();
+}
+
+// node_modules/@vitest/coverage-v8/dist/pathe.M-eThtNZ-BTaAGrLg.js
+var _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
+function normalizeWindowsPath(input = "") {
+  if (!input) {
+    return input;
+  }
+  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r2) => r2.toUpperCase());
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var normalize = function(path) {
+  if (path.length === 0) {
+    return ".";
+  }
+  path = normalizeWindowsPath(path);
+  const isUNCPath = path.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path);
+  const trailingSeparator = path[path.length - 1] === "/";
+  path = normalizeString(path, !isPathAbsolute);
+  if (path.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path)) {
+    path += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path}`;
+    }
+    return `//${path}`;
+  }
+  return isPathAbsolute && !isAbsolute(path) ? `/${path}` : path;
+};
+function normalizeString(path, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path.length; ++index) {
+    if (index < path.length) {
+      char = path[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1) ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p2) {
+  return _IS_ABSOLUTE_RE.test(p2);
+};
+
+// node_modules/@vitest/coverage-v8/dist/index.js
+var session = new inspector.Session();
+var enabled = false;
+var mod = {
+  async startCoverage({ isolate }) {
+    if (isolate === false && enabled) {
+      return;
+    }
+    enabled = true;
+    session.connect();
+    await session.post("Profiler.enable");
+    await session.post("Profiler.startPreciseCoverage", {
+      callCount: true,
+      detailed: true
+    });
+  },
+  async takeCoverage(options) {
+    if (f === "stackblitz") {
+      return { result: [] };
+    }
+    const coverage = await session.post("Profiler.takePreciseCoverage");
+    const result = [];
+    for (const entry of coverage.result) {
+      if (filterResult(entry)) {
+        result.push({
+          ...entry,
+          startOffset: options?.moduleExecutionInfo?.get(normalize(fileURLToPath(entry.url)))?.startOffset || 0
+        });
+      }
+    }
+    return { result };
+  },
+  async stopCoverage({ isolate }) {
+    if (isolate === false) {
+      return;
+    }
+    await session.post("Profiler.stopPreciseCoverage");
+    await session.post("Profiler.disable");
+    session.disconnect();
+  },
+  async getProvider() {
+    return loadProvider();
+  }
+};
+function filterResult(coverage) {
+  if (!coverage.url.startsWith("file://")) {
+    return false;
+  }
+  if (coverage.url.includes("/node_modules/")) {
+    return false;
+  }
+  if (coverage.url.includes("/@id/@vitest/")) {
+    return false;
+  }
+  if (coverage.url.includes("/@vite/client")) {
+    return false;
+  }
+  return true;
+}
+
+// src/index.ts
+var import_deepmerge = __toESM(require_cjs(), 1);
+var defaultTestConfig = {
+  coverage: {
+    provider: mod,
+    reporter: ["text", "text-summary", "cobertura", "html", "json", "lcov"],
+    include: ["src/**/*.[jt]s"],
+    exclude: [
+      "**/*.cy.ts",
+      "**/*.d.ts",
+      "**/__fixtures__/**",
+      "**/generated/**",
+      "**/index.[jt]s",
+      "**/temp/**"
+    ]
+  },
+  reporters: ["default", ["junit", { suiteName: "Vitest tests" }]],
+  outputFile: "./temp/vitest-junit.xml",
+  exclude: ["**/.git/**", "**/build/**", "**/dist/**", "**/node_modules/**", "**/temp/**"]
+};
+function overwriteMerge(_a, b2) {
+  return b2;
+}
+function defineTestConfig(userConfig = {}) {
+  return (0, import_deepmerge.default)(defaultTestConfig, userConfig, { arrayMerge: overwriteMerge });
+}
+export {
+  defineTestConfig
+};

package/package.json

@@ -1,10 +1,43 @@
 {
   "name": "@html-validate/vitest-config",
-  "version": "0.0.0",
-  "description": "OIDC trusted publishing setup package for @html-validate/vitest-config",
+  "version": "1.0.0",
+  "description": "Vitest shareable preset used by the various HTML-validate packages",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+    "vitest"
+  ],
+  "homepage": "https://gitlab.com/html-validate/vitest-config#readme",
+  "bugs": {
+    "url": "https://gitlab.com/html-validate/vitest-config/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/html-validate/vitest-config.git"
+  },
+  "license": "MIT",
+  "author": "David Sveningsson <ext@sidvind.com>",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "dependencies": {
+    "@vitest/coverage-v8": "^4.1.0"
+  },
+  "peerDependencies": {
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": "^22.16 || ^24 || >= 26",
+    "npm": ">= 10"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }