@visulima/package 4.1.4 → 4.1.6

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+## @visulima/package [4.1.6](https://github.com/visulima/visulima/compare/@visulima/package@4.1.5...@visulima/package@4.1.6) (2025-11-13)
+
+### Bug Fixes
+
+* bump packem, to fix minified version of the code ([2a36ceb](https://github.com/visulima/visulima/commit/2a36ceb09251b0ca1178701a26547a871ed717a7))
+
+
+### Dependencies
+
+* **@visulima/fs:** upgraded to 4.0.6
+* **@visulima/path:** upgraded to 2.0.5
+
+## @visulima/package [4.1.5](https://github.com/visulima/visulima/compare/@visulima/package@4.1.4...@visulima/package@4.1.5) (2025-11-12)
+
+### Bug Fixes
+
+* **deps:** update type-fest dependency across multiple packages ([93e13be](https://github.com/visulima/visulima/commit/93e13be5248207968a96303710db2a0604d16b9b))
+* update package configurations and TypeScript definitions ([b59aa59](https://github.com/visulima/visulima/commit/b59aa59dac1508216b944f4b917fb4a7ab1f70a4))
+
+### Miscellaneous Chores
+
+* Add jsr file to all packages for release ([#565](https://github.com/visulima/visulima/issues/565)) ([ec91652](https://github.com/visulima/visulima/commit/ec91652b4e4112adf14ba152c1239a7703ba425a))
+* update license files and clean up TypeScript definitions ([fe668cc](https://github.com/visulima/visulima/commit/fe668cc26de23591d4df54a0954455ebbe31b22d))
+
+
+### Dependencies
+
+* **@visulima/fs:** upgraded to 4.0.5
+* **@visulima/path:** upgraded to 2.0.4
+
 ## @visulima/package [4.1.4](https://github.com/visulima/visulima/compare/@visulima/package@4.1.3...@visulima/package@4.1.4) (2025-11-07)
 
 ### Bug Fixes

package/LICENSE.md

@@ -47,11 +47,14 @@ Repository: sindresorhus/dot-prop
 <!-- TYPE_DEPENDENCIES -->
 
 # Licenses of bundled types
+
 The published @visulima/package artifact additionally contains code with the following licenses:
 MIT
 
 # Bundled types:
+
 ## @inquirer/core
+
 License: MIT
 By: Simon Boudrias
 Repository: https://github.com/SBoudrias/Inquirer.js.git
@@ -79,9 +82,10 @@ Repository: https://github.com/SBoudrias/Inquirer.js.git
 > FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 > OTHER DEALINGS IN THE SOFTWARE.
 
----------------------------------------
+---
 
 ## @inquirer/type
+
 License: MIT
 By: Simon Boudrias
 Repository: https://github.com/SBoudrias/Inquirer.js.git

package/dist/error/package-not-found-error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Error thrown when a package was not found.
+ */
+declare class PackageNotFoundError extends Error {
+    /**
+     * @param packageName The name of the package that was not found.
+     * @param packageManager The package manager used to install the package.
+     */
+    constructor(packageName: string[] | string, packageManager?: string);
+    get code(): string;
+    set code(_name: string);
+    get name(): string;
+    set name(_name: string);
+}
+export default PackageNotFoundError;

package/dist/error.d.ts

@@ -1,9 +1 @@
-declare class PackageNotFoundError extends Error {
-    constructor(packageName: string[] | string, packageManager?: string);
-    get code(): string;
-    set code(_name: string);
-    get name(): string;
-    set name(_name: string);
-}
-
-export { PackageNotFoundError };
+export { default as PackageNotFoundError } from "./error/package-not-found-error.d.ts";

package/dist/index.d.ts

@@ -1,10 +1,11 @@
-export { PackageNotFoundError } from './error.js';
-export { RootMonorepo, Strategy, findMonorepoRoot, findMonorepoRootSync } from './monorepo.js';
-export { findPackageRoot, findPackageRootSync } from './package.js';
-export { E as EnsurePackagesOptions, F as FindPackageJsonCache, i as NormalizedPackageJson, N as NormalizedReadResult, P as PackageJson, e as ensurePackages, f as findPackageJson, a as findPackageJsonSync, g as getPackageJsonProperty, h as hasPackageJsonAnyDependency, b as hasPackageJsonProperty, p as parsePackageJson, c as parsePackageJsonSync, w as writePackageJson, d as writePackageJsonSync } from './packem_shared/package-json-CiMqtMwD.js';
-export { PackageManager, PackageManagerResult, findLockFile, findLockFileSync, findPackageManager, findPackageManagerSync, generateMissingPackagesInstallMessage, getPackageManagerVersion, identifyInitiatingPackageManager } from './package-manager.js';
-export { PnpmCatalog, PnpmCatalogs, isPackageInWorkspace, readPnpmCatalogs, readPnpmCatalogsSync, resolveCatalogReference, resolveCatalogReferences, resolveDependenciesCatalogReferences } from './pnpm.js';
-import '@visulima/fs';
-import 'type-fest';
-import '@antfu/install-pkg';
-import 'normalize-package-data';
+export { default as PackageNotFoundError } from "./error/package-not-found-error.d.ts";
+export type { RootMonorepo, Strategy } from "./monorepo.d.ts";
+export { findMonorepoRoot, findMonorepoRootSync } from "./monorepo.d.ts";
+export { findPackageRoot, findPackageRootSync } from "./package.d.ts";
+export type { FindPackageJsonCache, NormalizedReadResult } from "./package-json.d.ts";
+export { ensurePackages, findPackageJson, findPackageJsonSync, getPackageJsonProperty, hasPackageJsonAnyDependency, hasPackageJsonProperty, parsePackageJson, parsePackageJsonSync, writePackageJson, writePackageJsonSync, } from "./package-json.d.ts";
+export type { PackageManager, PackageManagerResult } from "./package-manager.d.ts";
+export { findLockFile, findLockFileSync, findPackageManager, findPackageManagerSync, generateMissingPackagesInstallMessage, getPackageManagerVersion, identifyInitiatingPackageManager, } from "./package-manager.d.ts";
+export type { PnpmCatalog, PnpmCatalogs } from "./pnpm.d.ts";
+export { isPackageInWorkspace, readPnpmCatalogs, readPnpmCatalogsSync, resolveCatalogReference, resolveCatalogReferences, resolveDependenciesCatalogReferences, } from "./pnpm.d.ts";
+export type { EnsurePackagesOptions, NormalizedPackageJson, PackageJson } from "./types.d.ts";

package/dist/monorepo.d.ts

@@ -1,10 +1,25 @@
-type Strategy = "lerna" | "npm" | "pnpm" | "turbo" | "yarn";
-interface RootMonorepo<T extends Strategy = Strategy> {
+export type Strategy = "lerna" | "npm" | "pnpm" | "turbo" | "yarn";
+export interface RootMonorepo<T extends Strategy = Strategy> {
     path: string;
     strategy: T;
 }
-declare const findMonorepoRoot: (cwd?: URL | string) => Promise<RootMonorepo>;
-declare const findMonorepoRootSync: (cwd?: URL | string) => RootMonorepo;
-
-export { findMonorepoRoot, findMonorepoRootSync };
-export type { RootMonorepo, Strategy };
+/**
+ * An asynchronous function to find the root directory path and strategy for a monorepo based on
+ * the given current working directory (cwd).
+ * @param cwd The current working directory. The type of `cwd` is part of an `Options` type, specifically `Options["cwd"]`.
+ * Default is undefined.
+ * @returns A `Promise` that resolves to the root directory path and strategy for the monorepo.
+ * The type of the returned promise is `Promise&lt;RootMonorepo>`.
+ * @throws An `Error` if no monorepo root can be found using lerna, yarn, pnpm, or npm as indicators.
+ */
+export declare const findMonorepoRoot: (cwd?: URL | string) => Promise<RootMonorepo>;
+/**
+ * An function to find the root directory path and strategy for a monorepo based on
+ * the given current working directory (cwd).
+ * @param cwd The current working directory. The type of `cwd` is part of an `Options` type, specifically `Options["cwd"]`.
+ * Default is undefined.
+ * @returns A `Promise` that resolves to the root directory path and strategy for the monorepo.
+ * The type of the returned promise is `Promise&lt;RootMonorepo>`.
+ * @throws An `Error` if no monorepo root can be found using lerna, yarn, pnpm, or npm as indicators.
+ */
+export declare const findMonorepoRootSync: (cwd?: URL | string) => RootMonorepo;

package/dist/package-json.d.ts

@@ -1,5 +1,138 @@
-import '@visulima/fs';
-import 'type-fest';
-export { F as FindPackageJsonCache, N as NormalizedReadResult, e as ensurePackages, f as findPackageJson, a as findPackageJsonSync, g as getPackageJsonProperty, h as hasPackageJsonAnyDependency, b as hasPackageJsonProperty, p as parsePackageJson, c as parsePackageJsonSync, w as writePackageJson, d as writePackageJsonSync } from './packem_shared/package-json-CiMqtMwD.js';
-import '@antfu/install-pkg';
-import 'normalize-package-data';
+import type { WriteJsonOptions } from "@visulima/fs";
+import type { JsonObject, Paths } from "type-fest";
+import type { Cache, EnsurePackagesOptions, NormalizedPackageJson, PackageJson } from "./types.d.ts";
+type ReadOptions = {
+    cache?: FindPackageJsonCache | boolean;
+    ignoreWarnings?: (RegExp | string)[];
+    json5?: boolean;
+    resolveCatalogs?: boolean;
+    strict?: boolean;
+    yaml?: boolean;
+};
+export type FindPackageJsonCache = Cache<NormalizedReadResult>;
+export type NormalizedReadResult = {
+    packageJson: NormalizedPackageJson;
+    path: string;
+};
+/**
+ * An asynchronous function to find the package.json, package.yaml, or package.json5 file in the specified directory or its parent directories.
+ * @param cwd The current working directory.
+ * @param options Configuration options including yaml, json5, and resolveCatalogs flags.
+ * @returns A `Promise` that resolves to an object containing the parsed package data and the file path.
+ * The type of the returned promise is `Promise&lt;NormalizedReadResult>`.
+ * @throws {Error} If no package file can be found or if strict mode is enabled and normalize warnings are thrown.
+ */
+export declare const findPackageJson: (cwd?: URL | string, options?: ReadOptions) => Promise<NormalizedReadResult>;
+/**
+ * A synchronous function to find the package.json, package.yaml, or package.json5 file in the specified directory or its parent directories.
+ * @param cwd The current working directory.
+ * @param options Configuration options including yaml, json5, and resolveCatalogs flags.
+ * @returns An object containing the parsed package data and the file path.
+ * @throws {Error} If no package file can be found or if strict mode is enabled and normalize warnings are thrown.
+ */
+export declare const findPackageJsonSync: (cwd?: URL | string, options?: ReadOptions) => NormalizedReadResult;
+/**
+ * An asynchronous function to write the package.json file with the given data.
+ * @param data The package.json data to write. The data is an intersection type of `PackageJson` and a record where keys are `string` and values can be any type.
+ * @param options Optional. The options for writing the package.json. If not provided, an empty object will be used `{}`.
+ * This is an intersection type of `WriteJsonOptions` and a record with an optional `cwd` key which type is `Options["cwd"]`.
+ * `cwd` represents the current working directory. If not specified, the default working directory will be used.
+ * @returns A `Promise` that resolves once the package.json file has been written. The type of the returned promise is `Promise&lt;void>`.
+ */
+export declare const writePackageJson: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
+    cwd?: URL | string;
+}) => Promise<void>;
+export declare const writePackageJsonSync: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
+    cwd?: URL | string;
+}) => void;
+/**
+ * A synchronous function to parse the package.json, package.yaml, or package.json5 file/object/string and return normalize the data.
+ * @param packageFile
+ * @param options
+ * @param options.cache Cache for parsed results (only applies to file paths)
+ * @param options.ignoreWarnings List of warning messages or patterns to skip in strict mode
+ * @param options.resolveCatalogs Whether to resolve pnpm catalog references
+ * @param options.strict Whether to throw errors on normalization warnings
+ * @param options.yaml Whether to enable package.yaml parsing (default: true)
+ * @param options.json5 Whether to enable package.json5 parsing (default: true)
+ * @returns
+ * @throws {Error} If the packageFile parameter is not an object or a string or if strict mode is enabled and normalize warnings are thrown.
+ */
+export declare const parsePackageJsonSync: (packageFile: JsonObject | string, options?: {
+    cache?: Cache<NormalizedPackageJson> | boolean;
+    ignoreWarnings?: (RegExp | string)[];
+    json5?: boolean;
+    resolveCatalogs?: boolean;
+    strict?: boolean;
+    yaml?: boolean;
+}) => NormalizedPackageJson;
+/**
+ * An asynchronous function to parse the package.json, package.yaml, or package.json5 file/object/string and return normalize the data.
+ * @param packageFile
+ * @param options
+ * @param options.cache Cache for parsed results (only applies to file paths)
+ * @param options.ignoreWarnings List of warning messages or patterns to skip in strict mode
+ * @param options.strict Whether to throw errors on normalization warnings
+ * @param options.resolveCatalogs Whether to resolve pnpm catalog references
+ * @param options.yaml Whether to enable package.yaml parsing (default: true)
+ * @param options.json5 Whether to enable package.json5 parsing (default: true)
+ * @returns
+ * @throws {Error} If the packageFile parameter is not an object or a string or if strict mode is enabled and normalize warnings are thrown.
+ */
+export declare const parsePackageJson: (packageFile: JsonObject | string, options?: {
+    cache?: Cache<NormalizedPackageJson> | boolean;
+    ignoreWarnings?: (RegExp | string)[];
+    json5?: boolean;
+    resolveCatalogs?: boolean;
+    strict?: boolean;
+    yaml?: boolean;
+}) => Promise<NormalizedPackageJson>;
+/**
+ * An asynchronous function to get the value of a property from the package.json file.
+ * @param packageJson
+ * @param property
+ * @param defaultValue
+ * @returns
+ */
+export declare const getPackageJsonProperty: <T = unknown>(packageJson: NormalizedPackageJson, property: Paths<NormalizedPackageJson>, defaultValue?: T) => T;
+/**
+ * An asynchronous function to check if a property exists in the package.json file.
+ * @param packageJson
+ * @param property
+ * @returns
+ */
+export declare const hasPackageJsonProperty: (packageJson: NormalizedPackageJson, property: Paths<NormalizedPackageJson>) => boolean;
+/**
+ * An asynchronous function to check if any of the specified dependencies exist in the package.json file.
+ * @param packageJson
+ * @param arguments_
+ * @param options
+ * @param options.peerDeps Whether to include peer dependencies
+ * @returns
+ */
+export declare const hasPackageJsonAnyDependency: (packageJson: NormalizedPackageJson, arguments_: string[], options?: {
+    peerDeps?: boolean;
+}) => boolean;
+/**
+ * An asynchronous function to ensure that the specified packages are installed in the package.json file.
+ * If the packages are not installed, the user will be prompted to install them.
+ * If the user agrees, the packages will be installed.
+ * If the user declines, the function will return without installing the packages.
+ * If the user does not respond, the function will return without installing the packages.
+ * @param packageJson
+ * @param packages
+ * @param installKey
+ * @param options
+ * @param options.deps Whether to include regular dependencies
+ * @param options.devDeps Whether to include development dependencies
+ * @param options.peerDeps Whether to include peer dependencies
+ * @param options.throwOnWarn Whether to throw an error when warnings are logged instead of just logging them
+ * @param options.logger Whether to use a custom logger
+ * @param options.confirm Whether to use a custom confirmation prompt
+ * @param options.installPackage Whether to use a custom installation package
+ * @param options.cwd Whether to use a custom current working directory
+ * @param options.dev Whether to use a custom installation key
+ * @returns
+ */
+export declare const ensurePackages: (packageJson: NormalizedPackageJson, packages: string[], installKey?: "dependencies" | "devDependencies", options?: EnsurePackagesOptions) => Promise<void>;
+export {};

package/dist/package-manager.d.ts

@@ -1,22 +1,71 @@
-declare const findLockFile: (cwd?: URL | string) => Promise<string>;
-declare const findLockFileSync: (cwd?: URL | string) => string;
-type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
-type PackageManagerResult = {
+/**
+ * An asynchronous function that finds a lock file in the specified directory or any of its parent directories.
+ * @param cwd Optional. The directory path to start the search from. The type of `cwd` is part of an `Options` type,
+ * specifically `URL | string`. Defaults to the current working directory.
+ * @returns A `Promise` that resolves with the path of the found lock file.
+ * The type of the returned promise is `Promise&lt;string>`.
+ * @throws An `Error` if no lock file is found.
+ */
+export declare const findLockFile: (cwd?: URL | string) => Promise<string>;
+export declare const findLockFileSync: (cwd?: URL | string) => string;
+export type PackageManager = "bun" | "npm" | "pnpm" | "yarn";
+export type PackageManagerResult = {
     packageManager: PackageManager;
     path: string;
 };
-declare const findPackageManager: (cwd?: URL | string) => Promise<PackageManagerResult>;
-declare const findPackageManagerSync: (cwd?: URL | string) => PackageManagerResult;
-declare const getPackageManagerVersion: (name: string) => string;
-declare const identifyInitiatingPackageManager: () => Promise<{
+/**
+ * An asynchronous function that finds the package manager used in a project based on the presence of lock files
+ * or package.json configuration. If found, it returns the package manager and the path to the lock file or package.json.
+ * Throws an error if no lock file or package.json is found.
+ * @param cwd Optional. The current working directory to start the search from. The type of `cwd` is part of an `Options`
+ * type, specifically `URL | string`.
+ * @returns A `Promise` that resolves to an object containing the package manager and path.
+ * The return type of the function is `Promise&lt;PackageManagerResult>`.
+ * @throws An `Error` if no lock file or package.json is found.
+ */
+export declare const findPackageManager: (cwd?: URL | string) => Promise<PackageManagerResult>;
+/**
+ * An function that finds the package manager used in a project based on the presence of lock files
+ * or package.json configuration. If found, it returns the package manager and the path to the lock file or package.json.
+ * Throws an error if no lock file or package.json is found.
+ * @param cwd Optional. The current working directory to start the search from. The type of `cwd` is part of an `Options`
+ * type, specifically `URL | string`.
+ * @returns A `Promise` that resolves to an object containing the package manager and path.
+ * The return type of the function is `Promise&lt;PackageManagerResult>`.
+ * @throws An `Error` if no lock file or package.json is found.
+ */
+export declare const findPackageManagerSync: (cwd?: URL | string) => PackageManagerResult;
+/**
+ * Function that retrieves the version of the specified package manager.
+ * @param name The name of the package manager. The type of `name` is `string`.
+ * @returns The version of the package manager. The return type of the function is `string`.
+ */
+export declare const getPackageManagerVersion: (name: string) => string;
+/**
+ * An asynchronous function that detects what package manager executes the process.
+ *
+ * Supports npm, pnpm, Yarn, cnpm, and bun. And also any other package manager that sets the npm_config_user_agent env variable.
+ * @returns A `Promise` that resolves to an object containing the name and version of the package manager,
+ * or undefined if the package manager information cannot be determined. The return type of the function
+ * is `Promise&lt;{ name: PackageManager | "cnpm"; version: string } | undefined>`.
+ */
+export declare const identifyInitiatingPackageManager: () => Promise<{
     name: PackageManager | "cnpm";
     version: string;
 } | undefined>;
-declare const generateMissingPackagesInstallMessage: (packageName: string, missingPackages: string[], options: {
+/**
+ * Function that generates a message to install missing packages.
+ * @param packageName The name of the package that requires the missing packages.
+ * @param missingPackages An array of missing package names.
+ * @param options An object containing optional parameters:
+ * @param options.packageManagers An array of package managers to include in the message. Defaults to \["npm", "pnpm", "yarn"\].
+ * @param options.postMessage A string to append to the end of the message.
+ * @param options.preMessage A string to prepend to the beginning of the message.
+ * @returns A string message with instructions to install the missing packages using the specified package managers.
+ * @throws An `Error` if no package managers are provided in the options.
+ */
+export declare const generateMissingPackagesInstallMessage: (packageName: string, missingPackages: string[], options: {
     packageManagers?: PackageManager[];
     postMessage?: string;
     preMessage?: string;
 }) => string;
-
-export { findLockFile, findLockFileSync, findPackageManager, findPackageManagerSync, generateMissingPackagesInstallMessage, getPackageManagerVersion, identifyInitiatingPackageManager };
-export type { PackageManager, PackageManagerResult };

package/dist/package.d.ts

@@ -1,4 +1,11 @@
-declare const findPackageRoot: (cwd?: URL | string) => Promise<string>;
-declare const findPackageRootSync: (cwd?: URL | string) => string;
-
-export { findPackageRoot, findPackageRootSync };
+/**
+ * An asynchronous function that finds the root directory of a project based on certain lookup criteria.
+ * @param cwd Optional. The current working directory to start the search from. The type of `cwd` is `string`.
+ * @returns A `Promise` that resolves to the path of the root directory. The type of the returned promise is `Promise&lt;string>`.
+ * @throws An `Error` if the root directory could not be found.
+ * @example
+ * const rootDirectory = await findPackageRoot();
+ * console.log(rootDirectory); // '/path/to/project'
+ */
+export declare const findPackageRoot: (cwd?: URL | string) => Promise<string>;
+export declare const findPackageRootSync: (cwd?: URL | string) => string;

package/dist/pnpm.d.ts

@@ -1,16 +1,18 @@
-import { JsonObject } from 'type-fest';
-
-type PnpmCatalog = Record<string, string>;
-type PnpmCatalogs = {
+import type { JsonObject } from "type-fest";
+export type PnpmCatalog = Record<string, string>;
+export type PnpmCatalogs = {
     catalog?: PnpmCatalog;
     catalogs?: Record<string, PnpmCatalog>;
 };
-declare const isPackageInWorkspace: (workspacePath: string, packagePath: string, workspacePackages: string[]) => boolean;
-declare const readPnpmCatalogs: (packagePath: string) => Promise<PnpmCatalogs | undefined>;
-declare const readPnpmCatalogsSync: (packagePath: string) => PnpmCatalogs | undefined;
-declare const resolveCatalogReference: (packageName: string, versionSpec: string, catalogs: PnpmCatalogs) => string | undefined;
-declare const resolveDependenciesCatalogReferences: (dependencies: Record<string, string>, catalogs: PnpmCatalogs) => void;
-declare const resolveCatalogReferences: (packageJson: JsonObject, catalogs: PnpmCatalogs) => void;
-
-export { isPackageInWorkspace, readPnpmCatalogs, readPnpmCatalogsSync, resolveCatalogReference, resolveCatalogReferences, resolveDependenciesCatalogReferences };
-export type { PnpmCatalog, PnpmCatalogs };
+/** Checks if a package directory is included in the workspace packages configuration. */
+export declare const isPackageInWorkspace: (workspacePath: string, packagePath: string, workspacePackages: string[]) => boolean;
+/** Reads, parses, and resolves catalogs from a pnpm-workspace file found by walking up the directory tree. */
+export declare const readPnpmCatalogs: (packagePath: string) => Promise<PnpmCatalogs | undefined>;
+/** Reads, parses, and resolves catalogs from a pnpm-workspace file found by walking up the directory tree (synchronous). */
+export declare const readPnpmCatalogsSync: (packagePath: string) => PnpmCatalogs | undefined;
+/** Resolves a single catalog reference to its actual version. */
+export declare const resolveCatalogReference: (packageName: string, versionSpec: string, catalogs: PnpmCatalogs) => string | undefined;
+/** Resolves catalog references in a single dependency object. */
+export declare const resolveDependenciesCatalogReferences: (dependencies: Record<string, string>, catalogs: PnpmCatalogs) => void;
+/** Resolves catalog references in package.json dependencies using the provided catalogs. */
+export declare const resolveCatalogReferences: (packageJson: JsonObject, catalogs: PnpmCatalogs) => void;

package/dist/types.d.ts

@@ -0,0 +1,37 @@
+import type { InstallPackageOptions } from "@antfu/install-pkg";
+import type { Theme } from "@inquirer/core";
+import type { PartialDeep } from "@inquirer/type";
+import type { Package as normalizePackage } from "normalize-package-data";
+import type { PackageJson as typeFestPackageJson } from "type-fest";
+export type NormalizedPackageJson = normalizePackage & PackageJson;
+export type PackageJson = typeFestPackageJson;
+export type Cache<T = any> = Map<string, T>;
+export type EnsurePackagesOptions = {
+    /** Configuration for user confirmation prompts when installing packages */
+    confirm?: {
+        /** Default value for the confirmation prompt */
+        default?: boolean;
+        /** Message to display in the confirmation prompt, or a function that receives packages array */
+        message: string | ((packages: string[]) => string);
+        /** Theme configuration for the prompt interface */
+        theme?: PartialDeep<Theme>;
+        /** Function to transform the boolean value for display */
+        transformer?: (value: boolean) => string;
+    };
+    /** Current working directory for package operations */
+    cwd?: URL | string;
+    /** Whether to include regular dependencies in the operation */
+    deps?: boolean;
+    /** Whether to include development dependencies in the operation */
+    devDeps?: boolean;
+    /** Additional options for package installation (excluding cwd and dev which are handled separately) */
+    installPackage?: Omit<InstallPackageOptions, "cwd" | "dev">;
+    /** Custom logger interface for warning messages */
+    logger?: {
+        warn: (message: string) => void;
+    };
+    /** Whether to include peer dependencies in the operation */
+    peerDeps?: boolean;
+    /** Whether to throw an error when warnings are logged instead of just logging them */
+    throwOnWarn?: boolean;
+};

package/dist/utils/is-node.d.ts

@@ -0,0 +1,2 @@
+declare const isNode: boolean;
+export default isNode;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visulima/package",
-  "version": "4.1.4",
+  "version": "4.1.6",
   "description": "A comprehensive package management utility that helps you find root directories, monorepos, package managers, and parse package.json, package.yaml, and package.json5 files with advanced features like catalog resolution.",
   "keywords": [
     "anolilab",
@@ -97,12 +97,11 @@
   ],
   "dependencies": {
     "@antfu/install-pkg": "^1.1.0",
-    "@inquirer/confirm": "^5.1.19",
-    "@visulima/fs": "4.0.4",
-    "@visulima/path": "2.0.3",
+    "@inquirer/confirm": "^5.1.20",
+    "@visulima/fs": "4.0.6",
+    "@visulima/path": "2.0.5",
     "json5": "^2.2.3",
     "normalize-package-data": "^8.0.0",
-    "type-fest": "^5.2.0",
     "yaml": "^2.8.1"
   },
   "engines": {

package/dist/packem_shared/package-json-CiMqtMwD.d.ts

@@ -1,232 +0,0 @@
-import { WriteJsonOptions } from '@visulima/fs';
-import { PackageJson as PackageJson$1, Paths, JsonObject } from 'type-fest';
-import { InstallPackageOptions } from '@antfu/install-pkg';
-import { Package } from 'normalize-package-data';
-
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-type PartialDeep<T> = T extends object ? {
-    [P in keyof T]?: PartialDeep<T[P]>;
-} : T;
-
-/**
- * Union type representing the possible statuses of a prompt.
- *
- * -   `'loading'`: The prompt is currently loading.
- * -   `'idle'`: The prompt is loaded and currently waiting for the user to
- *     submit an answer.
- * -   `'done'`: The user has submitted an answer and the prompt is finished.
- * -   `string`: Any other string: The prompt is in a custom state.
- */
-type Status = 'loading' | 'idle' | 'done' | (string & {});
-type DefaultTheme = {
-    /**
-     * Prefix to prepend to the message. If a function is provided, it will be
-     * called with the current status of the prompt, and the return value will be
-     * used as the prefix.
-     *
-     * @remarks
-     * If `status === 'loading'`, this property is ignored and the spinner (styled
-     * by the `spinner` property) will be displayed instead.
-     *
-     * @defaultValue
-     * ```ts
-     * // import colors from 'yoctocolors-cjs';
-     * (status) => status === 'done' ? colors.green('✔') : colors.blue('?')
-     * ```
-     */
-    prefix: string | Prettify<Omit<Record<Status, string>, 'loading'>>;
-    /**
-     * Configuration for the spinner that is displayed when the prompt is in the
-     * `'loading'` state.
-     *
-     * We recommend the use of {@link https://github.com/sindresorhus/cli-spinners|cli-spinners} for a list of available spinners.
-     */
-    spinner: {
-        /**
-         * The time interval between frames, in milliseconds.
-         *
-         * @defaultValue
-         * ```ts
-         * 80
-         * ```
-         */
-        interval: number;
-        /**
-         * A list of frames to show for the spinner.
-         *
-         * @defaultValue
-         * ```ts
-         * ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-         * ```
-         */
-        frames: string[];
-    };
-    /**
-     * Object containing functions to style different parts of the prompt.
-     */
-    style: {
-        /**
-         * Style to apply to the user's answer once it has been submitted.
-         *
-         * @param text - The user's answer.
-         * @returns The styled answer.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(text)
-         * ```
-         */
-        answer: (text: string) => string;
-        /**
-         * Style to apply to the message displayed to the user.
-         *
-         * @param text - The message to style.
-         * @param status - The current status of the prompt.
-         * @returns The styled message.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text, status) => colors.bold(text)
-         * ```
-         */
-        message: (text: string, status: Status) => string;
-        /**
-         * Style to apply to error messages.
-         *
-         * @param text - The error message.
-         * @returns The styled error message.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.red(`> ${text}`)
-         * ```
-         */
-        error: (text: string) => string;
-        /**
-         * Style to apply to the default answer when one is provided.
-         *
-         * @param text - The default answer.
-         * @returns The styled default answer.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.dim(`(${text})`)
-         * ```
-         */
-        defaultAnswer: (text: string) => string;
-        /**
-         * Style to apply to help text.
-         *
-         * @param text - The help text.
-         * @returns The styled help text.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.dim(text)
-         * ```
-         */
-        help: (text: string) => string;
-        /**
-         * Style to apply to highlighted text.
-         *
-         * @param text - The text to highlight.
-         * @returns The highlighted text.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(text)
-         * ```
-         */
-        highlight: (text: string) => string;
-        /**
-         * Style to apply to keyboard keys referred to in help texts.
-         *
-         * @param text - The key to style.
-         * @returns The styled key.
-         *
-         * @defaultValue
-         * ```ts
-         * // import colors from 'yoctocolors-cjs';
-         * (text) => colors.cyan(colors.bold(`<${text}>`))
-         * ```
-         */
-        key: (text: string) => string;
-    };
-};
-type Theme<Extension extends object = object> = Prettify<Extension & DefaultTheme>;
-
-type NormalizedPackageJson = Package & PackageJson;
-type PackageJson = PackageJson$1;
-type Cache<T = any> = Map<string, T>;
-type EnsurePackagesOptions = {
-    confirm?: {
-        default?: boolean;
-        message: string | ((packages: string[]) => string);
-        theme?: PartialDeep<Theme>;
-        transformer?: (value: boolean) => string;
-    };
-    cwd?: URL | string;
-    deps?: boolean;
-    devDeps?: boolean;
-    installPackage?: Omit<InstallPackageOptions, "cwd" | "dev">;
-    logger?: {
-        warn: (message: string) => void;
-    };
-    peerDeps?: boolean;
-    throwOnWarn?: boolean;
-};
-
-type ReadOptions = {
-    cache?: FindPackageJsonCache | boolean;
-    ignoreWarnings?: (RegExp | string)[];
-    json5?: boolean;
-    resolveCatalogs?: boolean;
-    strict?: boolean;
-    yaml?: boolean;
-};
-type FindPackageJsonCache = Cache<NormalizedReadResult>;
-type NormalizedReadResult = {
-    packageJson: NormalizedPackageJson;
-    path: string;
-};
-declare const findPackageJson: (cwd?: URL | string, options?: ReadOptions) => Promise<NormalizedReadResult>;
-declare const findPackageJsonSync: (cwd?: URL | string, options?: ReadOptions) => NormalizedReadResult;
-declare const writePackageJson: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
-    cwd?: URL | string;
-}) => Promise<void>;
-declare const writePackageJsonSync: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
-    cwd?: URL | string;
-}) => void;
-declare const parsePackageJsonSync: (packageFile: JsonObject | string, options?: {
-    cache?: Cache<NormalizedPackageJson> | boolean;
-    ignoreWarnings?: (RegExp | string)[];
-    json5?: boolean;
-    resolveCatalogs?: boolean;
-    strict?: boolean;
-    yaml?: boolean;
-}) => NormalizedPackageJson;
-declare const parsePackageJson: (packageFile: JsonObject | string, options?: {
-    cache?: Cache<NormalizedPackageJson> | boolean;
-    ignoreWarnings?: (RegExp | string)[];
-    json5?: boolean;
-    resolveCatalogs?: boolean;
-    strict?: boolean;
-    yaml?: boolean;
-}) => Promise<NormalizedPackageJson>;
-declare const getPackageJsonProperty: <T = unknown>(packageJson: NormalizedPackageJson, property: Paths<NormalizedPackageJson>, defaultValue?: T) => T;
-declare const hasPackageJsonProperty: (packageJson: NormalizedPackageJson, property: Paths<NormalizedPackageJson>) => boolean;
-declare const hasPackageJsonAnyDependency: (packageJson: NormalizedPackageJson, arguments_: string[], options?: {
-    peerDeps?: boolean;
-}) => boolean;
-declare const ensurePackages: (packageJson: NormalizedPackageJson, packages: string[], installKey?: "dependencies" | "devDependencies", options?: EnsurePackagesOptions) => Promise<void>;
-
-export { findPackageJsonSync as a, hasPackageJsonProperty as b, parsePackageJsonSync as c, writePackageJsonSync as d, ensurePackages as e, findPackageJson as f, getPackageJsonProperty as g, hasPackageJsonAnyDependency as h, parsePackageJson as p, writePackageJson as w };
-export type { EnsurePackagesOptions as E, FindPackageJsonCache as F, NormalizedReadResult as N, PackageJson as P, NormalizedPackageJson as i };