void 0.10.12 → 0.20.0

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/monorepo.md

@@ -1,176 +0,0 @@
-# Monorepo
-
-Vite+ supports monorepos with `vite.config.ts` at the root. You can define the defaults for `lint`, `fmt`, etc. at the root, and use `overrides` to apply package-specific lint and format settings.
-
-Because `vite.config.ts` is just JavaScript, you can choose to put your entire config into this file or compose it using regular JavaScript imports. You can still have separate `vite.config.ts` files in each package for the Vite, Vitest, framework or runtime configuration.
-
-## Root Config With Overrides
-
-Use `lint.overrides` for Oxlint rules that only apply to some packages:
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  lint: {
-    plugins: ['typescript'],
-    options: {
-      typeAware: true,
-      typeCheck: true,
-    },
-    rules: {
-      'no-console': ['error', { allow: ['warn', 'error'] }],
-    },
-    overrides: [
-      {
-        files: ['apps/web/**', 'packages/ui/**'],
-        plugins: ['typescript', 'react'],
-        rules: {
-          'react/self-closing-comp': 'error',
-        },
-      },
-      {
-        files: ['apps/api/**'],
-        env: {
-          node: true,
-        },
-        rules: {
-          'no-console': 'off',
-        },
-      },
-      {
-        files: ['**/*.test.ts', '**/*.spec.ts'],
-        plugins: ['typescript', 'vitest'],
-        rules: {
-          '@typescript-eslint/no-explicit-any': 'off',
-          'vitest/no-disabled-tests': 'error',
-        },
-      },
-    ],
-  },
-});
-```
-
-Globs are resolved from the root `vite.config.ts`, so use workspace paths such as `apps/web/**`, `apps/api/**`, and `packages/ui/**`.
-
-::: tip
-When a `lint.overrides` entry sets `plugins`, that list replaces the base `lint.plugins` list for matched files. Include every plugin needed by that file group, such as `['typescript', 'react']`. Omit `plugins` only when the override should inherit the base list unchanged.
-:::
-
-## Format Overrides
-
-Use `fmt.overrides` for file or package-specific Oxfmt options. Formatter overrides put their settings under `options`:
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  fmt: {
-    singleQuote: true,
-    semi: true,
-    overrides: [
-      {
-        files: ['apps/api/**'],
-        options: {
-          printWidth: 120,
-        },
-      },
-      {
-        files: ['**/*.md'],
-        options: {
-          proseWrap: 'always',
-        },
-      },
-    ],
-  },
-});
-```
-
-## Composing Configuration Files
-
-You can split configuration across your repository and compose them using JavaScript imports. Export JavaScript objects from nearby files or packages, import them in the root config, and merge them into the matching override.
-
-```ts [tooling/lint/react.ts]
-import type { OxlintOverride } from 'vite-plus/lint';
-
-export const reactLint = {
-  plugins: ['typescript', 'react'],
-  rules: {
-    'react/self-closing-comp': 'error',
-  },
-} satisfies Omit<OxlintOverride, 'files'>;
-```
-
-```ts [tooling/lint/node.ts]
-import type { OxlintOverride } from 'vite-plus/lint';
-
-export const nodeLint = {
-  env: {
-    node: true,
-  },
-  rules: {
-    'no-console': 'off',
-  },
-} satisfies Omit<OxlintOverride, 'files'>;
-```
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-import { nodeLint } from './tooling/lint/node';
-import { reactLint } from './tooling/lint/react';
-
-export default defineConfig({
-  lint: {
-    plugins: ['typescript'],
-    options: {
-      typeAware: true,
-      typeCheck: true,
-    },
-    overrides: [
-      {
-        files: ['apps/web/**', 'packages/ui/**'],
-        ...reactLint,
-      },
-      {
-        files: ['apps/api/**'],
-        ...nodeLint,
-      },
-    ],
-  },
-});
-```
-
-This keeps the behavior centralized while letting each team or package own the pieces of config it needs.
-
-## App Commands
-
-The root `vite.config.ts` is most valuable for shared linting, formatting, staged checks, and task definitions. For project-specific development, build, and test behavior, use the setup that best matches each app:
-
-- Pass a folder to built-in Vite commands when you want to target one app:
-
-```bash
-vp dev apps/web
-vp build apps/web
-```
-
-- Keep package-specific scripts in each package when the command differs per app:
-
-```json [apps/api/package.json]
-{
-  "scripts": {
-    "dev": "tsx watch src/index.ts",
-    "build": "tsc -p tsconfig.json"
-  }
-}
-```
-
-- Run scripts across the workspace with `vp run`:
-
-```bash
-vp run -r build
-vp run -r --parallel dev
-vp run --filter ./apps/web build
-```
-
-See the [Run guide](/guide/run) for recursive, parallel, filtered, and cached workspace tasks.

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/pack.md

@@ -1,69 +0,0 @@
-# Pack
-
-`vp pack` builds libraries for production with [tsdown](https://tsdown.dev/guide/).
-
-## Overview
-
-`vp pack` builds libraries and standalone executables with tsdown. Use it for publishable packages and binary outputs. If you want to build a web application, use `vp build`. `vp pack` covers everything you need for building libraries out of the box, including declaration file generation, multiple output formats, source maps, and minification.
-
-For more information about how tsdown works, see the official [tsdown guide](https://tsdown.dev/guide/).
-
-## Usage
-
-```bash
-vp pack
-vp pack src/index.ts --dts
-vp pack --watch
-```
-
-## Configuration
-
-Put packaging configuration directly in the `pack` block in `vite.config.ts` so all your configuration stays in one place. We do not recommend using `tsdown.config.ts` with Vite+.
-
-See the [tsdown guide](https://tsdown.dev/guide/) and the [tsdown config file docs](https://tsdown.dev/options/config-file) to learn more about how to use and configure `vp pack`.
-
-Use it for:
-
-- [declaration files (`dts`)](https://tsdown.dev/options/dts)
-- [output formats](https://tsdown.dev/options/output-format)
-- [watch mode](https://tsdown.dev/options/watch-mode)
-- [standalone executables](https://tsdown.dev/options/exe#executable)
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  pack: {
-    dts: true,
-    format: ['esm', 'cjs'],
-    sourcemap: true,
-  },
-});
-```
-
-## Standalone Executables
-
-`vp pack` can also build standalone executables through tsdown's experimental [`exe` option](https://tsdown.dev/options/exe#executable).
-
-Use this when you want to ship a CLI or other Node-based tool as a native executable that runs without requiring Node.js to be installed separately.
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  pack: {
-    entry: ['src/cli.ts'],
-    exe: true,
-  },
-});
-```
-
-Executable support is bundled into Vite+, so you do not need to install `@tsdown/exe` separately.
-
-Building executables uses Node's [Single Executable Applications](https://nodejs.org/api/single-executable-applications.html) support and requires Node.js 25.7.0 or later. Switch the active runtime with `vp env use 26` if `vp pack --exe` reports an unsupported version.
-
-See the official [tsdown executable docs](https://tsdown.dev/options/exe#executable) for details about configuring custom file names, embedded assets, and cross-platform targets.
-
-## CSS Bundling
-
-`vp pack` can transform and bundle CSS (including CSS Modules and [Lightning CSS](https://lightningcss.dev/) optimizations) for your entry points. This support is bundled into Vite+, so you do not need to install `@tsdown/css` or `lightningcss` separately, it works out of the box.

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/run.md

@@ -1,356 +0,0 @@
-# Run
-
-`vp run` runs `package.json` scripts and tasks defined in `vite.config.ts`. It works like `pnpm run`, with caching, dependency ordering, and workspace-aware execution built in.
-
-::: tip
-`vpr` is available as a standalone shorthand for `vp run`. All examples below work with both `vp run` and `vpr`.
-:::
-
-## Overview
-
-Use `vp run` with existing `package.json` scripts:
-
-```json [package.json]
-{
-  "scripts": {
-    "build": "node compile-legacy-app.js",
-    "test": "jest"
-  }
-}
-```
-
-`vp run build` executes the associated build script:
-
-```
-$ node compile-legacy-app.js
-
-building legacy app for production...
-
-✓ built in 69s
-```
-
-Use `vp run` without a task name to use the interactive task runner:
-
-```
-Select a task (↑/↓, Enter to run, Esc to clear):
-
-  › build: node compile-legacy-app.js
-    test: jest
-```
-
-## Caching
-
-`package.json` scripts are not cached by default. Use `--cache` to enable caching:
-
-```bash
-vp run --cache build
-```
-
-```
-$ node compile-legacy-app.js
-✓ built in 69s
-```
-
-If nothing changes, the output is replayed from the cache on the next run:
-
-```
-$ node compile-legacy-app.js ✓ cache hit, replaying
-✓ built in 69s
-
----
-vp run: cache hit, 69s saved.
-```
-
-If an input changes, the task runs again:
-
-```
-$ node compile-legacy-app.js ✗ cache miss: 'legacy/index.js' modified, executing
-```
-
-## Task Definitions
-
-Vite Task [automatically tracks](/guide/automatic-data-tracking) what each task needs for caching. You can define tasks directly in `vite.config.ts` to enable caching by default or control which files and environment variables affect cache behavior.
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  run: {
-    tasks: {
-      build: {
-        command: 'vp build',
-        dependsOn: ['lint'],
-        env: ['NODE_ENV'],
-      },
-      deploy: {
-        command: 'deploy-script --prod',
-        cache: false,
-        dependsOn: ['build', 'test'],
-      },
-    },
-  },
-});
-```
-
-If you want to run an existing `package.json` script as-is, use `vp run <script>`. If you want task-level caching, dependencies, or environment/input controls, define a task with an explicit `command`. A task name can come from `vite.config.ts` or `package.json`, but not both.
-
-::: info
-Tasks defined in `vite.config.ts` are cached by default. `package.json` scripts are not. See [When Is Caching Enabled?](/guide/cache#when-is-caching-enabled) for the full resolution order.
-:::
-
-See [Run Config](/config/run) for the full `run` block reference.
-
-## Task Dependencies
-
-Use [`dependsOn`](/config/run#dependson) to run tasks in the right order. Running `vp run deploy` with the config above runs `build` and `test` first.
-
-String task names in `dependsOn` reference tasks in the current or another package:
-
-```ts [vite.config.ts]
-dependsOn: [
-  'build', // same package
-  '@my/core#build', // another package
-];
-```
-
-Use the object form when you need to reference all tasks with a given name from the current package's dependencies:
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  run: {
-    tasks: {
-      test: {
-        command: 'vp test',
-        dependsOn: [{ task: 'build', from: 'dependencies' }],
-      },
-    },
-  },
-});
-```
-
-In this example, `vp run test` checks the current package's `dependencies`. For each direct workspace dependency that defines `build`, Vite Task runs that dependency's `build` task before `test`.
-
-Use an array when you need more than one dependency field:
-
-```ts [vite.config.ts]
-dependsOn: [{ task: 'build', from: ['dependencies', 'devDependencies'] }];
-```
-
-## Running in a Workspace
-
-With no package-selection flags, `vp run` runs the task in the package in your current working directory:
-
-```bash
-cd packages/app
-vp run build
-```
-
-You can also target a package explicitly from anywhere:
-
-```bash
-vp run @my/app#build
-```
-
-Workspace package ordering is based on the normal monorepo dependency graph declared in each package's `package.json`. In other words, when Vite+ talks about package dependencies, it means the regular `dependencies` relationships between workspace packages, not a separate task-runner-specific graph.
-
-### Recursive (`-r`)
-
-Run the task in every workspace package, in dependency order:
-
-```bash
-vp run -r build
-```
-
-That dependency order comes from the workspace packages referenced through `package.json` dependencies.
-
-### Transitive (`-t`)
-
-Run the task in one package and all of its dependencies:
-
-```bash
-vp run -t @my/app#build
-```
-
-If `@my/app` depends on `@my/utils`, which depends on `@my/core`, this runs all three in order. Vite+ resolves that chain from the normal workspace package dependencies declared in `package.json`.
-
-### Filter (`--filter`)
-
-Select packages by name, directory, or glob pattern. The syntax matches pnpm's `--filter`:
-
-```bash
-# By name
-vp run --filter @my/app build
-
-# By glob
-vp run --filter "@my/*" build
-
-# By directory
-vp run --filter ./packages/app build
-
-# Include dependencies
-vp run --filter "@my/app..." build
-
-# Include dependents
-vp run --filter "...@my/core" build
-
-# Exclude packages
-vp run --filter "@my/*" --filter "!@my/utils" build
-```
-
-Multiple `--filter` flags are combined as a union. Exclusion filters are applied after all inclusions.
-
-When a `--filter` matches no packages, Vite+ prints a warning and exits successfully. Pass `--fail-if-no-match` to abort the run when any filter matches nothing instead.
-
-### Workspace Root (`-w`)
-
-Explicitly run the task in the workspace root package:
-
-```bash
-vp run -w build
-```
-
-## Compound Commands
-
-Commands joined with `&&` are split into independent sub-tasks. Each sub-task is cached separately when [caching is enabled](/guide/cache#when-is-caching-enabled). This works for both `vite.config.ts` tasks and `package.json` scripts:
-
-```json [package.json]
-{
-  "scripts": {
-    "check": "vp lint && vp build"
-  }
-}
-```
-
-Now, run `vp run --cache check`:
-
-```
-$ vp lint
-Found 0 warnings and 0 errors.
-
-$ vp build
-✓ built in 28ms
-
----
-vp run: 0/2 cache hit (0%).
-```
-
-Each sub-task has its own cache entry. If only `.ts` files changed but lint still passes, only `vp build` runs again the next time `vp run --cache check` is called:
-
-```
-$ vp lint ✓ cache hit, replaying
-$ vp build ✗ cache miss: 'src/index.ts' modified, executing
-✓ built in 30ms
-
----
-vp run: 1/2 cache hit (50%), 120ms saved.
-```
-
-### Nested `vp run`
-
-When a command contains `vp run`, Vite Task inlines it as separate tasks instead of spawning a nested process. Each sub-task is cached independently and output stays flat:
-
-```json [package.json]
-{
-  "scripts": {
-    "ci": "vp run lint && vp run test && vp run build"
-  }
-}
-```
-
-Running `vp run ci` expands into three tasks:
-
-```mermaid
-graph LR
-  lint --> test --> build
-```
-
-Flags also work inside nested scripts. For example, `vp run -r build` inside a script expands into individual build tasks for every package.
-
-::: info
-A common monorepo pattern is a root script that runs a task recursively:
-
-```json [package.json (root) ~vscode-icons:file-type-node~]
-{
-  "scripts": {
-    "build": "vp run -r build"
-  }
-}
-```
-
-This creates a potential recursion: root's `build` -> `vp run -r build` -> includes root's `build` -> ...
-
-Vite Task detects this and prunes the self-reference automatically, so other packages build normally.
-:::
-
-## Execution Summary
-
-Use `-v` to show a detailed execution summary:
-
-```bash
-vp run -r -v build
-```
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-    Vite+ Task Runner • Execution Summary
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-Statistics:   3 tasks • 3 cache hits • 0 cache misses
-Performance:  100% cache hit rate, 468ms saved in total
-
-Task Details:
-────────────────────────────────────────────────
-  [1] @my/core#build: ~/packages/core$ vp build ✓
-      → Cache hit - output replayed - 200ms saved
-  ·······················································
-  [2] @my/utils#build: ~/packages/utils$ vp build ✓
-      → Cache hit - output replayed - 150ms saved
-  ·······················································
-  [3] @my/app#build: ~/packages/app$ vp build ✓
-      → Cache hit - output replayed - 118ms saved
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-Use `--last-details` to show the summary from the last run without running tasks again:
-
-```bash
-vp run --last-details
-```
-
-## Concurrency
-
-By default, up to 4 tasks run at the same time. Use `--concurrency-limit` to change this:
-
-```bash
-# Run up to 8 tasks at once
-vp run -r --concurrency-limit 8 build
-
-# Run tasks one at a time
-vp run -r --concurrency-limit 1 build
-```
-
-The limit can also be set via the `VP_RUN_CONCURRENCY_LIMIT` environment variable. The `--concurrency-limit` flag takes priority over the environment variable.
-
-### Parallel Mode
-
-Use `--parallel` to ignore task dependencies and run all tasks at once with unlimited concurrency:
-
-```bash
-vp run -r --parallel dev
-```
-
-This is useful when tasks are independent and you want maximum throughput. You can combine `--parallel` with `--concurrency-limit` to run tasks without dependency ordering but still cap the number of concurrent tasks:
-
-```bash
-vp run -r --parallel --concurrency-limit 4 dev
-```
-
-## Additional Arguments
-
-Arguments after the task name are passed through to the task command:
-
-```bash
-vp run test --reporter verbose
-```

package/skills/void/docs/node_modules/void/node_modules/@void/md/node_modules/vite-plus/docs/guide/test.md

@@ -1,35 +0,0 @@
-# Test
-
-`vp test` runs tests with [Vitest](https://vitest.dev).
-
-## Overview
-
-`vp test` is built on [Vitest](https://vitest.dev/), so you get a Vite-native test runner that reuses your Vite config and plugins, supports Jest-style expectations, snapshots, and coverage, and handles modern ESM, TypeScript, and JSX projects cleanly.
-
-## Usage
-
-```bash
-vp test
-vp test watch
-vp test run --coverage
-```
-
-::: info
-Unlike Vitest on its own, `vp test` does not stay in watch mode by default. Use `vp test` when you want a normal test run, and use `vp test watch` when you want to jump into watch mode.
-:::
-
-## Configuration
-
-Put test configuration directly in the `test` block in `vite.config.ts` so all your configuration stays in one place. We do not recommend using `vitest.config.ts` with Vite+.
-
-```ts [vite.config.ts]
-import { defineConfig } from 'vite-plus';
-
-export default defineConfig({
-  test: {
-    include: ['src/**/*.test.ts'],
-  },
-});
-```
-
-For the full Vitest configuration reference, see the [Vitest config docs](https://vitest.dev/config/).