creatium 0.2.1 → 0.2.2

package/dist/utils.d.ts

@@ -0,0 +1,1013 @@
+import { boxen } from '@visulima/boxen';
+import { TableConstructorOptions } from 'cli-table3';
+import columnify from 'columnify';
+import * as p from '@clack/prompts';
+import * as fs from 'fs';
+import { readFile as readFile$1, writeFile as writeFile$1 } from 'node:fs/promises';
+import glob from 'tiny-glob';
+import { homedir } from 'node:os';
+export { default as currentProcess } from 'node:process';
+export { deepmerge, deepmergeCustom } from 'deepmerge-ts';
+export { fileURLToPath } from 'node:url';
+
+declare const isBrowser: boolean;
+declare const isNode: boolean;
+declare const isWebWorker: boolean;
+declare const isJsDom: boolean;
+declare const isDeno: boolean;
+declare const isBun: boolean;
+/**
+ * True if the environment is a development environment.
+ */
+declare const isDev: boolean;
+
+declare const env: {
+    isBrowser: boolean;
+    isWebWorker: boolean;
+    isNode: boolean;
+    isJsDom: boolean;
+    isDeno: boolean;
+    isBun: boolean;
+};
+
+/**
+ * Executes a command in the shell and waits for it to finish.
+ *
+ * @param   {string}        cmd - The command to execute.
+ * @returns {Promise<void>}     - A promise that resolves when the command finishes successfully.
+ * @throws {Error} - Throws an error if the command fails.
+ */
+declare const exec: (cmd: string) => Promise<void>;
+/**
+ * Executes a command in a child process and captures its output.
+ *
+ * @param   {string}                                      cmd - The command to execute.
+ * @returns {Promise<{ stdout: string; stderr: string }>}     - A promise that resolves with the output of the command.
+ * @throws {Error} - Throws an error if the command fails, along with its stdout and stderr.
+ */
+declare const execChild: (cmd: string) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Executes a command and captures its output.
+ *
+ * @param   {string}          command - The command to execute, including any arguments.
+ * @returns {Promise<string>}         A promise that resolves with the captured output (stdout).
+ * @throws Will reject with an error if the command fails.
+ * @example
+ * const [error, output] = await catchExecOutput('dovenv --help')
+ * if (error) {
+ *   console.error(error);
+ * } else {
+ *   await writeFile('dovenvHelp.txt', output)
+ * }
+ */
+declare const catchExecOutput: <Res = string>(command: string) => Promise<[Error] | [undefined, Res]>;
+declare const existsLocalBin: (binName: string) => Promise<boolean>;
+declare const existsLocalBins: <Bin extends string>(binaries: Bin[]) => Promise<{ [key in Bin]: boolean; }>;
+
+/**
+ * Prompt for number type.
+ *
+ * @param   {NumberParams}             opts - NumberOptions.
+ * @returns {Promise<number | symbol>}      - Promise resolving the answer.
+ * @example
+ * const age = await number({
+ *   message: 'What is your age?',
+ *   errorText: 'Failed getting age',
+ * });
+ * console.log(age)
+ */
+declare function number(opts: NumberParams): Promise<number | symbol>;
+
+type GradientColors = string[] | {
+    color: string;
+    pos: number;
+}[];
+type GradientOpts = {
+    /**
+       The gradient can be generated using RGB or HSV interpolation. HSV usually produces brighter colors. Interpolation can be set to rgb for RGB interpolation, orhsv for HSV interpolation.
+       Defaults to rgb. Case insentitive.
+     */
+    interpolation?: 'rgb' | 'hsv';
+    /**
+       Used only in the case of HSV interpolation.
+       Because hue can be considered as a circle, there are two ways to go from a color to another color.
+       HsvSpin can be either short or long, depending on if you want to take the shortest or the longest way between two colors.
+       Defaults to short. Case insensitive.
+     */
+    hsvSpin?: 'short' | 'long';
+};
+
+/**
+ * Provides colors for terminal output.
+ *
+ * @type {object}
+ * @example
+ * console.log(color.green('This text is green'));
+ */
+declare const color: Record<"black" | "blackBright" | "blue" | "blueBright" | "cyan" | "cyanBright" | "gray" | "green" | "greenBright" | "grey" | "magenta" | "magentaBright" | "red" | "redBright" | "white" | "whiteBright" | "yellow" | "yellowBright" | "bgBlack" | "bgBlackBright" | "bgBlue" | "bgBlueBright" | "bgCyan" | "bgCyanBright" | "bgGray" | "bgGreen" | "bgGreenBright" | "bgGrey" | "bgMagenta" | "bgMagentaBright" | "bgRed" | "bgRedBright" | "bgWhite" | "bgWhiteBright" | "bgYellow" | "bgYellowBright" | "blink" | "bold" | "dim" | "doubleunderline" | "framed" | "hidden" | "inverse" | "italic" | "overlined" | "reset" | "strikethrough" | "underline", (v: string) => string>;
+/**
+ * Generates a gradient string with the specified colors.
+ *
+ * @param   {string}         txt    - The text to apply the gradient to.
+ * @param   {GradientColors} colors - An array of color names or hex values.
+ * @param   {GradientOpts}   [opts] - Custom opts.
+ * @returns {string}                - The text with the applied gradient.
+ * @example
+ * // Example usage:
+ * const gradientText = gradient('Gradient Text', ['red', 'yellow', 'green']);
+ * console.log(gradientText);
+ */
+declare const gradient: (txt: string, colors: GradientColors, opts?: GradientOpts) => string;
+
+declare const line: ({ title, lineChar, align, }: {
+    title?: string;
+    lineChar?: string;
+    align?: "left" | "center" | "right";
+}) => string;
+
+type TableData = string[][];
+type BoxOpts = Parameters<typeof boxen>[1];
+type ColumnOpts = columnify.GlobalOptions;
+type ColumnData = Record<string, unknown> | Record<string, unknown>[];
+/**
+ * Generates a text-based table from the provided data array.
+ *
+ * @param   {TableData} data      - The data to display in the table.
+ * @param   {TableOpts} [options] - Optional configuration options for the table.
+ * @returns {string}              - The text-based table.
+ * @see https://www.npmjs.com/package/table
+ * @example
+ * const data = [
+ *     ['Name', 'Age', 'Country'],
+ *     ['John', 30, 'USA'],
+ *     ['Alice', 25, 'UK'],
+ *     ['Bob', 35, 'Canada'],
+ * ];
+ * const tableText = table(data);
+ * console.log(tableText);
+ */
+declare const table: (data: TableData, options?: TableConstructorOptions) => string;
+/**
+ * Creates a styled box around the provided text.
+ *
+ * @param   {string}  text      - The text to display inside the box.
+ * @param   {BoxOpts} [options] - Optional configuration options for the box.
+ * @returns {string}            - The text with the styled box around it.
+ * @see https://www.npmjs.com/package/boxen
+ * @example
+ * const boxedText = box('This is a boxed text', { padding: 1 });
+ * console.log(boxedText);
+ */
+declare const box: (text: string, options?: BoxOpts) => string;
+/**
+ * Formats data into aligned columns for better readability.
+ *
+ * @param   {ColumnData} data      - The data to format into columns.
+ * @param   {ColumnOpts} [options] - Optional configuration options for column formatting.
+ * @returns {string}               - The text with the data formatted into columns.
+ * @see https://www.npmjs.com/package/columnify
+ * @example
+ * // data for columns
+ * const data = [
+ *     {
+ *         name: 'mod1',
+ *         description: 'some description which happens to be far larger than the max',
+ *         version: '0.0.1',
+ *     },
+ *     {
+ *         name: 'module-two',
+ *         description: 'another description larger than the max',
+ *         version: '0.2.0',
+ *     }
+ * ];
+ *
+ * // set columns with custom config
+ * const columnText = columns(data, {
+ *     showHeaders: false,
+ *     minWidth: 20,
+ *     config: {
+ *         description: {
+ *             maxWidth: 30
+ *         }
+ *     }
+ * });
+ *
+ * // print columns
+ * console.log(columnText);
+ */
+declare const columns: <Data extends ColumnData>(data: Data, options?: ColumnOpts) => string;
+
+type EmptyObject = {};
+/**
+ * Any Array type
+ * Same as `any[]` type. Used only for prevent ts errors
+ */
+type AnyArray = any[];
+/**
+ * Any type
+ * Same as `any` type. Used only for prevent ts errors
+ */
+type Any = any;
+/**
+ * Values of Object
+ */
+type ObjectValues<Values> = Values[keyof Values];
+/**
+ * Keys of Object
+ */
+type ObjectKeys<Values> = keyof Values;
+/**
+ * DeepPartial
+ */
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+/**
+ * Prettify your type for better readability
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * NonUndefined
+ *
+ * @description Exclude undefined from set `A`
+ * @example
+ *   // Expect: "string | null"
+ *   SymmetricDifference<string | null | undefined>;
+ */
+type NonUndefined<A> = A extends undefined ? never : A;
+/**
+ * FunctionKeys
+ *
+ * @description Get union type of keys that are functions in object type `T`
+ * @example
+ *  type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};
+ *
+ *   // Expect: "setName | someFn"
+ *   type Keys = FunctionKeys<MixedProps>;
+ */
+type FunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends Function ? K : never;
+}[keyof T];
+/**
+ * NonFunctionKeys
+ *
+ * @description Get union type of keys that are non-functions in object type `T`
+ * @example
+ *   type MixedProps = {name: string; setName: (name: string) => void; someKeys?: string; someFn?: (...args: any) => any;};
+ *
+ *   // Expect: "name | someKey"
+ *   type Keys = NonFunctionKeys<MixedProps>;
+ */
+type NonFunctionKeys<T extends object> = {
+    [K in keyof T]-?: NonUndefined<T[K]> extends Function ? never : K;
+}[keyof T];
+/**
+ * AssertEqual
+ *
+ * @description Checks if two types `T` and `U` are equal.
+ * @example
+ *   type Test = AssertEqual<string, string>; // Expected: true
+ *   type TestFail = AssertEqual<string, number>; // Expected: false
+ */
+type AssertEqual<T, U> = (<V>() => V extends T ? 1 : 2) extends (<V>() => V extends U ? 1 : 2) ? true : false;
+/**
+ * ExpectEqual
+ *
+ * @description Returns the type `T` if `T` and `U` are equal; otherwise, returns `never`.
+ * @example
+ *   type Test = ExpectEqual<string, string>; // Expected: string
+ *   type TestFail = ExpectEqual<string, number>; // Expected: never
+ */
+type ExpectEqual<T, U> = AssertEqual<T, U> extends true ? T : never;
+type SingleChar<T extends string = string> = T extends `${infer First}${infer Rest}` ? Rest extends '' ? First : never : never;
+type ObjectToArray<T extends Record<string, Any>, Key extends string = 'type'> = {
+    [K in keyof T]: T[K] & {
+        [k in Key]: K;
+    };
+}[keyof T][];
+
+declare const promptLineMethods: {
+    readonly message: "message";
+    readonly info: "info";
+    readonly success: "success";
+    readonly step: "step";
+    readonly warn: "warn";
+    readonly warning: "warning";
+    readonly error: "error";
+};
+type PromptLineMethod = typeof promptLineMethods[keyof typeof promptLineMethods];
+/**
+ * NUMBER.
+ *
+ */
+type NumberParams = Prettify<p.TextOptions & {
+    errorText?: string;
+}>;
+/**
+ * Parameters of the `table` function from the `@dovenv/utils` module.
+ *
+ * [See module](https://clippo.pigeonposse.com/guide/utils/style#table).
+ */
+type TableParams = Parameters<typeof table>;
+/**
+ * Parameters of the `columns` function from the `@dovenv/utils` module.
+ *
+ * [See module](https://clippo.pigeonposse.com/guide/utils/styles#columns).
+ */
+type ColumnsParams = Parameters<typeof columns>;
+/**
+ * Parameters of the `box` function from the `@dovenv/utils` module.
+ *
+ * [See module](https://clippo.pigeonposse.com/guide/utils/styles#box).
+ */
+type BoxParams = Parameters<typeof box>;
+
+declare const prompt: {
+    table: (opts: {
+        value: TableParams[0];
+        opts?: TableParams[1];
+        type?: PromptLineMethod;
+    }) => void;
+    columns: (opts: {
+        value: ColumnsParams[0];
+        opts?: ColumnsParams[1];
+        type?: PromptLineMethod;
+    }) => void;
+    box: (opts: {
+        value: BoxParams[0];
+        opts?: BoxParams[1];
+        type?: PromptLineMethod;
+    }) => void;
+    number: typeof number;
+    isCancel: typeof p.isCancel;
+    updateSettings: typeof p.updateSettings;
+    cancel: (message?: string) => void;
+    confirm: (opts: p.ConfirmOptions) => Promise<boolean | symbol>;
+    group: <T>(prompts: p.PromptGroup<T>, opts?: p.PromptGroupOptions<T> | undefined) => Promise<{ [P in keyof p.PromptGroupAwaitedReturn<T>]: p.PromptGroupAwaitedReturn<T>[P]; }>;
+    groupMultiselect: <Value>(opts: p.GroupMultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+    intro: (title?: string) => void;
+    log: {
+        message: (message?: string, { symbol }?: p.LogMessageOptions) => void;
+        info: (message: string) => void;
+        success: (message: string) => void;
+        step: (message: string) => void;
+        warn: (message: string) => void;
+        warning: (message: string) => void;
+        error: (message: string) => void;
+    };
+    multiselect: <Value>(opts: p.MultiSelectOptions<Value>) => Promise<symbol | Value[]>;
+    note: (message?: string, title?: string) => void;
+    outro: (message?: string) => void;
+    password: (opts: p.PasswordOptions) => Promise<string | symbol>;
+    select: <Value>(opts: p.SelectOptions<Value>) => Promise<symbol | Value>;
+    selectKey: <Value extends string>(opts: p.SelectOptions<Value>) => Promise<symbol | Value>;
+    spinner: ({ indicator }?: p.SpinnerOptions) => {
+        start: (msg?: string) => void;
+        stop: (msg?: string, code?: number) => void;
+        message: (msg?: string) => void;
+    };
+    stream: {
+        message: (iterable: Iterable<string> | AsyncIterable<string>, { symbol }?: p.LogMessageOptions) => Promise<void>;
+        info: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+        success: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+        step: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+        warn: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+        warning: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+        error: (iterable: Iterable<string> | AsyncIterable<string>) => Promise<void>;
+    };
+    tasks: (tasks: p.Task[]) => Promise<void>;
+    text: (opts: p.TextOptions) => Promise<string | symbol>;
+};
+
+type ParamFn = (arg: string) => Promise<string>;
+type ParamsValue = string | number | Record<string, unknown> | unknown[] | unknown;
+type Params = Record<string, ParamsValue>;
+type Props = {
+    /** Content to be replaced */
+    content: string;
+    /**
+     * Parameters
+     *
+     * @example
+     * const params = {
+     *     name: 'Antonio',
+     *     lastName : 'Resines'
+     * }
+     */
+    params: Params;
+    /**
+     * Transform parameters insde placeholders.
+     *
+     * @example
+     * const transform = async ( param: string ) => {
+     *     if ( param === 'url' ) return 'https://pigeonposse.com',
+     *     else if ( param === 'http://pigeonposse.com' ) return 'https://pigeonposse.com'
+     *     return param
+     * }
+     */
+    transform?: ParamFn;
+    /** Options */
+    opts?: {
+        /**
+         * Throw an error if a placeholder is not found.
+         *
+         * @default false
+         */
+        throw?: boolean;
+        /**
+         * Throw an error if a parameter is not found.
+         *
+         * @default
+         * {
+         *   prefix : '{{',
+         *   suffix : '}}',
+         * }
+         */
+        mark?: {
+            prefix: string;
+            suffix: string;
+        };
+    };
+};
+/**
+ * Replace placeholders in a string with their corresponding values.
+ *
+ * The function takes a string with placeholders, an object with parameter values,
+ * and an optional custom parameter function.
+ *
+ * The function returns a Promise that resolves to the string with all placeholders
+ * replaced.
+ *
+ * @param   {Props}              props             - Props for the function.
+ * @param   {Props['content']}   props.content     - The string with placeholders.
+ * @param   {Props['params']}    props.params      - An object with parameter values.
+ * @param   {Props['transform']} [props.transform] - An optional custom parameter function.
+ * @param   {Props['opts']}      [props.opts]      - Options to customize the behavior of the function.
+ * @returns {Promise<string>}                      - A Promise that resolves to the string with all placeholders replaced.
+ */
+declare const replacePlaceholders: (props: Props) => Promise<string>;
+
+declare const getStringType: (value: string) => "text" | "url" | "path";
+/**
+ * Joins the given URL parts into a single string.
+ *
+ * @param   {string[]} parts - The URL parts to join.
+ * @returns {string}         - The joined URL string.
+ */
+declare const joinUrl: (...parts: string[]) => string;
+/**
+ * Converts an object to a JSON string.
+ *
+ * @param   {unknown} data - The data to convert to a string.
+ * @returns {string}       - The JSON string representation of the data.
+ */
+declare const object2string: (data: unknown) => string;
+/**
+ * Truncates a given string to a maximum length and adds an ellipsis (...) at the end.
+ *
+ * @param   {string} text       - The string to truncate.
+ * @param   {number} maxLength  - The maximum length of the string.
+ * @param   {string} [ellipsis] - The ellipsis to add at the end of the truncated string (default is '…').
+ * @returns {string}            - The truncated string.
+ */
+declare const truncate: (text: string, maxLength: number, ellipsis?: string) => string;
+
+declare const resolvePath: (...paths: string[]) => string;
+declare const relativePath: (from: string, to: string) => string;
+declare const getExtName: (path: string) => string;
+declare const getDirName: (path: string) => string;
+declare const getBaseName: (path: string, suffix?: string) => string;
+declare const isAbsolutePath: (path: string) => boolean;
+declare const normalizePath: (path: string) => string;
+
+declare const writeFile: typeof writeFile$1;
+/**
+ * Find files and directories using glob patterns.
+ *
+ */
+declare const getPaths: typeof glob;
+/**
+ * Checks if two file paths are equal after normalization.
+ * Normalization ensures that differences like trailing slashes or redundant path segments are ignored.
+ *
+ * ---
+ *
+ * @param   {string}  path1 - The first file path to compare.
+ * @param   {string}  path2 - The second file path to compare.
+ * @returns {boolean}       `true` if the paths are equal, `false` otherwise.
+ */
+declare const arePathsEqual: (path1: string, path2: string) => boolean;
+/**
+ * Check if a string is a valid path.
+ *
+ * @param   {string}  str - The string to test.
+ * @returns {boolean}     True if the string is a valid path.
+ * @example
+ * isPath('..') // true
+ * isPath('foo bar') // false
+ * isPath('C:\\') // true
+ * isPath('foo\\bar') // true
+ * isPath('foo/bar') // true
+ * isPath('foo bar/baz') // false
+ */
+declare const isPath: (str: string) => boolean;
+/**
+ * Creates a directory if it does not exist.
+ *
+ * @param   {string}        path - Path to the directory to create.
+ * @returns {Promise<void>}      - A promise that resolves when the directory has been created.
+ * @example
+ * await ensureDir('./path/to/directory')
+ */
+declare const ensureDir: (path: string) => Promise<void>;
+/**
+ * Reads the contents of a directory.
+ *
+ * @param   {string}                              path - Path to the directory to read.
+ * @returns {Promise<import('node:fs').Dirent[]>}      - A promise that resolves to an array of {@link https://nodejs.org/api/fs.html#class-fs-dirent | fs.Dirent} objects.
+ * @example
+ * const dirItems = await readDir('./path/to/directory')
+ */
+declare const readDir: (path: string) => Promise<fs.Dirent<string>[]>;
+/**
+ * Gets the file names in a directory and filters them by extension.
+ *
+ * @param   {object}            props            - Function props.
+ * @param   {string}            props.path       - Path to the directory.
+ * @param   {string[]}          props.extensions - Array of extensions to filter by, e.g., ['.md', '.txt'].
+ * @returns {Promise<string[]>}                  - A promise that resolves with an array of file names without extensions.
+ */
+declare function getFilteredFileNames({ path, extensions, }: {
+    path: string;
+    extensions: string[];
+}): Promise<string[]>;
+/**
+ * Gets the current directory.
+ *
+ * @param   {string} [path] - An optional path to resolve the directory from.
+ * @returns {string}        - The current directory.
+ * @example getCurrentDir()
+ */
+declare const getCurrentDir: (path?: string) => string;
+/**
+ * Joins path segments.
+ *
+ * @param   {...string} paths - Path segments to join.
+ * @returns {string}          - The joined path.
+ * @example joinPath('user', 'pigeonposse')
+ */
+declare function joinPath(...paths: string[]): string;
+/**
+ * Resolves path segments into an absolute path.
+ *
+ * @param   {...string} paths - Path segments to resolve.
+ * @returns {string}          - The resolved absolute path.
+ */
+declare const getAbsolutePath: (...paths: string[]) => string;
+/**
+ * Validates and resolves a path with home directory replacement.
+ *
+ * @param   {string} path - The path to validate and resolve.
+ * @returns {string}      - The validated and resolved absolute path.
+ * @example
+ * import { validateHomeDir } from '@dovenv/utils'
+ *
+ * const path = validateHomeDir('~/Documents')
+ *
+ * console.log(path) // returns: /users/{username}/Documents
+ *
+ * const path = validateHomeDir('/Home')
+ *
+ * console.log(path) // returns same: /Home
+ */
+declare function validateHomeDir(path: string): string;
+/**
+ * Reads the content of a file at the specified path.
+ *
+ * @param   {string}                   path - The path of the file to read.
+ * @returns {Promise<string | Buffer>}      - A promise that resolves to the content of the file as a string or buffer.
+ * @throws {Error} If an error occurs while reading the file.
+ * @example import { readFile } from '@dovenv/utils'
+ *
+ * try {
+ *   const content = await readFile('./example.txt');
+ *   console.log(content);
+ * } catch (error) {
+ *   console.error('Error reading file:', error);
+ * }
+ */
+declare const readFile: typeof readFile$1;
+/**
+ * Removes a directory and its contents if it exists.
+ *
+ * @param {string} path - The path of the directory to remove.
+ * @throws {Error} If an error occurs while removing the directory.
+ * @example import { removeDir } from '@dovenv/utils'
+ *
+ * try {
+ *   await removeDir('./my/path')
+ * } catch (e) {
+ *   console.log(e)
+ * }
+ */
+declare function removeDir(path: string): Promise<void>;
+/**
+ * Removes a directory and its contents if it exists.
+ *
+ * @param {string} path - The path of the directory to remove.
+ * @throws {Error} If an error occurs while removing the directory.
+ * @example import { removeDirIfExist } from '@dovenv/utils'
+ *
+ * await removeDirIfExist('./my/path')
+ */
+declare function removeDirIfExist(path: string): Promise<void>;
+/**
+ * Removes a file or directory if it exists.
+ *
+ * @param {string} path - The path of the file or directory to remove.
+ * @throws {Error} If an error occurs while removing the file or directory.
+ * @example
+ * try {
+ *   await removePathIfExist('./my/path')
+ * } catch (e) {
+ *   console.log(e)
+ * }
+ */
+declare function removePathIfExist(path: string): Promise<void>;
+/**
+ * Removes a file if it exists.
+ *
+ * @param {string} path - The path of the file to remove.
+ * @throws {Error} If an error occurs while removing the file.
+ * @example
+ * try {
+ *   await removeFile('./my/path')
+ * } catch (e) {
+ *   console.log(e)
+ * }
+ */
+declare function removeFileIfExist(path: string): Promise<void>;
+/**
+ * Removes a file.
+ *
+ * @param {string} path - The path of the file to remove.
+ * @throws {Error} If an error occurs while removing the file.
+ * @example
+ * try {
+ *   await removeFile('./my/path')
+ * } catch (e) {
+ *   console.log(e)
+ * }
+ */
+declare function removeFile(path: string): Promise<void>;
+/**
+ * Checks if the given path points to a directory.
+ *
+ * @param   {string}           path - The path to check.
+ * @returns {Promise<boolean>}      - A promise that resolves to true if the path points to a directory, otherwise false.
+ * @example import { isDirectory } from '@dovenv/utils'
+ *
+ * const isDir = await isDirectory('./my/path')
+ */
+declare function isDirectory(path: string): Promise<boolean>;
+/**
+ * Creates a directory at the specified path.
+ *
+ * @param {string} path - The path of the directory to create.
+ * @throws {Error} If an error occurs while creating the directory.
+ * @example import { createDir } from '@dovenv/utils'
+ * await createDir('./my/dir')
+ */
+declare function createDir(path: string): Promise<void>;
+/**
+ * Checks if a directory exists at the specified path.
+ *
+ * @param   {string}           path - The path to check.
+ * @returns {Promise<boolean>}      - A promise that resolves to true if a directory exists at the specified path, otherwise false.
+ * @example import { existsDir } from '@dovenv/utils'
+ * const exist = await existsDir('./my/dir')
+ */
+declare function existsDir(path: string): Promise<boolean>;
+/**
+ * Checks if a file exists at the specified path.
+ *
+ * @param   {string}           path - The path to the file.
+ * @returns {Promise<boolean>}      - A promise that resolves to true if the file exists, otherwise false.
+ * @throws {Error} If an error occurs while checking the existence of the file.
+ * @example import { existsFile } from '@dovenv/utils'
+ *
+ * const existPKG = await existsFile('./package.json')
+ */
+declare function existsFile(path: string): Promise<boolean>;
+/**
+ * Writes content to a file at the specified path.
+ *
+ * @param {string}          path    - The path of the file to write to.
+ * @param {string | Buffer} content - The content to write to the file.
+ * @throws {Error} If an error occurs while writing to the file.
+ * @example import { writeFileContent } from '@dovenv/utils'
+ *
+ * await writeFileContent('./greetFile.txt', 'Hello')
+ */
+declare function writeFileContent(path: string, content: string | Buffer): Promise<void>;
+/**
+ * Checks if a file or directory exists at the specified path.
+ *
+ * @param   {string}           path - The path to check.
+ * @returns {Promise<boolean>}      - A promise that resolves to true if a file or directory exists at the specified path, otherwise false.
+ * @throws {Error} If an error occurs while checking the existence of the path.
+ * @example import { existsPath } from '@dovenv/utils'
+ *
+ * const existPKG = await existsPath('./package.json')
+ */
+declare function existsPath(path: string): Promise<boolean>;
+/**
+ * Creates a symbolic link from the input path to the output path.
+ *
+ * @param   {{input: string, output: string}} options - Options object with input and output paths.
+ * @returns {Promise<void>}                           - Resolves when the symbolic link has been created.
+ * @throws {Error} If there is an error creating the symbolic link.
+ * @example import { createSymlink } from '@dovenv/utils'
+ *
+ * const symlinkResult = await createSymlink({
+ *   input : '/path/to/source',
+ *   output: '/path/to/destination',
+ * })
+ */
+declare const createSymlink: ({ input, output, }: {
+    input: string;
+    output: string;
+}) => Promise<void>;
+
+type ContentInput = {
+    /**
+     * The name of the file
+     *
+     * @example 'index.html'
+     * @example 'src/index.js'
+     */
+    path: string;
+    content: string | Buffer;
+};
+type CopyDirOptions = {
+    /**
+     * The path of the directory to copy or an array of files and directories to copy.
+     */
+    input: ContentInput[] | string;
+    /**
+     * The path of the destination directory.
+     */
+    output: string;
+};
+declare const getContentDir: (input: string, opts?: Omit<Parameters<typeof getPaths>[1], "cwd" | "filesOnly"> & {
+    pattern?: string;
+    encoding?: Parameters<typeof readFile>[1];
+}) => Promise<ContentInput[]>;
+/**
+ * Copy a file from input path to output path.
+ *
+ * @param   {{input: string, output: string}} options - Options object with input and output paths.
+ * @returns {Promise<void>}                           - Resolves when the file has been copied.
+ * @throws {Error} If there is an error copying the file.
+ * @example import { copyFile } from '@dovenv/utils'
+ *
+ * const copyResult = await copyFile({
+ *   input : '/path/to/source.txt',
+ *   output: '/path/to/destination.txt',
+ * })
+ */
+declare const copyFile: ({ input, output, }: {
+    input: string;
+    output: string;
+}) => Promise<void>;
+/**
+ * Copy a directory from input path to output path.
+ *
+ * @param   {{input: string, output: string}} options - Options object with input and output paths.
+ * @returns {Promise<void>}                           - Resolves when the directory has been copied.
+ * @throws {Error} If there is an error copying the directory.
+ * @example
+ *
+ * const copyResult = await copyDir({
+ *   input : '/path/to/sourceDir',
+ *   output: '/path/to/destinationDir',
+ * })
+ *
+ * const copyResult = await copyDir({
+ *   input : [
+ *     { name: 'file1.txt', content: 'Hello, world!' },
+ *     { name: 'subfolder/subfile.txt', content: 'Subfolder content' } },
+ *   ],
+ *   output: '/path/to/destinationDir',
+  })
+ */
+declare const copyDir: ({ input, output, }: CopyDirOptions) => Promise<void>;
+
+declare const getHomeDir: typeof homedir;
+/**
+ * Returns the path to the operating system's temporary directory.
+ *
+ * @returns {string} The path to the operating system's temporary directory.
+ */
+declare const getTempDir: () => string;
+/**
+ * Determines the operating system.
+ *
+ * @returns {'windows' | 'macos' | 'linux' | 'unknown'} - The operating system. Possible values are 'linux', 'macos', or 'windows'.
+ */
+declare const getPlatform: () => Promise<"windows" | "macos" | "linux" | "unknown">;
+/**
+ * Returns the operating system CPU architecture.
+ *
+ * @returns {'arm64' | 'x64' | 'unknown'} - The operating system CPU architecture.
+ */
+declare function getArch(): 'arm64' | 'x64' | 'unknown';
+
+declare const getSystemEnvPaths: ({ name, suffix, }: {
+    name: string;
+    suffix?: string;
+}) => {
+    data: string;
+    config: string;
+    cache: string;
+    log: string;
+    temp: string;
+};
+
+type CacheOptions<Values extends Record<string, unknown>> = {
+    /**
+     * Project name for search cache.
+     * You can reuse the same cache for multiple instances.
+     */
+    projectName: string;
+    /**
+     * Identifier for the values.
+     */
+    id: string;
+    /**
+     * Cache Default Values.
+     */
+    values: Values;
+    /**
+     * Directory to save cache file.
+     * Default: System default user config directory.
+     * You most likely don't need this. Please don't use it unless you really have to.
+     */
+    cwd?: string;
+    /**
+     * Suffix for cache directory.
+     */
+    suffix?: string;
+};
+/**
+ * Creates a caching mechanism for storing and retrieving values.
+ *
+ * @param   {object} opts - Parameters for configuring the cache.
+ * @returns {object}      - An object with methods to interact with the cache.
+ * @throws {Error} If the cache value is unexpected or not found.
+ * @example
+ *
+ * const { get, set } = await cache({
+ *   projectName: 'myApp',
+ *   id: 'userSettings',
+ *   values: {
+ *      theme: 'dark',
+ *      language: 'en'
+ *   },
+ * });
+ *
+ * // Set a new value in the cache
+ * set({ theme: 'light' });
+ *
+ * // Retrieve a value from the cache
+ * const theme = get('theme');
+ * console.log(theme); // Output: 'light'
+ *
+ * // Retrieve all cached values
+ * const allValues = get();
+ * console.log(allValues); // Output: { theme: 'light', language: 'en' }
+ *
+ * // Handle unexpected cache value
+ * try {
+ *   const nonExistentValue = get('nonExistent');
+ * } catch (error) {
+ *   console.error('Error:', error.message); // Output: Cache value is unexpected: nonExistent
+ * }
+ */
+declare const cache: <Values extends Record<string, unknown>>(opts: CacheOptions<Values>) => Promise<{
+    /**
+     * The default values for the cache.
+     */
+    defaultValues: Values;
+    /**
+     * Retrieve a value from the cache.
+     *
+     * @example
+     * const theme = get('theme');
+     * console.log(theme); // Output: 'light'
+     */
+    get: <ID extends string | undefined = undefined>(v?: ID) => Promise<ID extends keyof Values ? Values[ID] : ID extends string ? undefined : Values>;
+    /**
+     * Updates the cache with the provided values.
+     *
+     * Merges the existing cached values with the new partial values and updates the cache.
+     */
+    set: (obj: Partial<Values>) => Promise<void>;
+    /**
+     * Resets the cache to its default values.
+     *
+     * @example
+     * reset();
+     */
+    reset: () => Promise<void>;
+    /**
+     * The path to the cache file.
+     */
+    path: string;
+}>;
+
+type CommonObj = Record<string, unknown> | Record<string, unknown>[] | unknown[];
+declare const getObjectFromJSONFile: <Res extends CommonObj = CommonObj>(path: string) => Promise<Res>;
+
+/**
+ * Finds the closest package.json by traversing up the directory tree.
+ *
+ * @param   {string} [startDir] - Directory to start searching from.
+ * @returns {string}            Absolute path to the closest package.json.
+ * @throws {Error} If no package.json is found.
+ */
+declare const getClosestPackageJson: (startDir?: string) => Promise<string>;
+/**
+ * Finds the closest package directory by traversing up the directory tree.
+ *
+ * @param   {string} [startDir] - Directory to start searching from.
+ * @returns {string}            Absolute path to the closest package directory.
+ */
+declare const getClosestPackageDir: (startDir?: string) => Promise<string>;
+
+/**
+ * DeepNonNullable
+ *
+ * @description NonNullable that works for deeply nested structure
+ * @example
+ *   type NestedProps = {
+ *     first?: null | {
+ *       second?: null | {
+ *         name?: string | null |
+ *         undefined;
+ *       };
+ *     };
+ *   };
+ *   type RequiredNestedProps = DeepNonNullable<NestedProps>;
+ *   // Expect: {
+ *   //   first: {
+ *   //     second: {
+ *   //       name: string;
+ *   //     };
+ *   //   };
+ *   // }
+ */
+type DeepNonNullable<T> = Prettify<_DeepNonNullable<T>>;
+type _DeepNonNullable<T> = T extends (...args: AnyArray) => Any ? T : T extends AnyArray ? Prettify<Array<_DeepNonNullable<NonNullable<T[number]>>>> : T extends object ? Prettify<{
+    [P in keyof T]-?: _DeepNonNullable<NonNullable<T[P]>>;
+}> : Prettify<NonNullable<T>>;
+
+type ReturnAwaitedType<T extends (...args: Any) => Any> = Awaited<ReturnType<T>>;
+type Response<V> = Promise<V> | V;
+type GetResponse<T> = T extends (...args: Any[]) => infer R ? Awaited<R> : T;
+
+/**
+ * DeepRequired
+ *
+ * @description Required that works for deeply nested structure
+ * @example
+ *   type NestedProps = {
+ *     first?: {
+ *       second?: {
+ *         name?: string;
+ *       };
+ *     };
+ *   };
+ *   type RequiredNestedProps = DeepRequired<NestedProps>
+ *   // Expect: {
+ *   //   first: {
+ *   //     second: {
+ *   //       name: string;
+ *   //     };
+ *   //   };
+ *   // }
+ */
+type DeepRequired<T> = Prettify<_DeepRequired<T>>;
+type _DeepRequired<T> = T extends (...args: AnyArray) => Any ? T : T extends AnyArray ? Prettify<_DeepRequiredArray<T[number]>> : T extends object ? Prettify<_DeepRequiredObject<T>> : T;
+type _DeepRequiredArray<T> = Array<_DeepRequired<NonUndefined<T>>>;
+type _DeepRequiredObject<T> = {
+    [P in keyof T]-?: _DeepRequired<NonUndefined<T[P]>>;
+};
+
+export { arePathsEqual, box, cache, catchExecOutput, color, columns, copyDir, copyFile, createDir, createSymlink, ensureDir, env, exec, execChild, existsDir, existsFile, existsLocalBin, existsLocalBins, existsPath, getAbsolutePath, getArch, getBaseName, getClosestPackageDir, getClosestPackageJson, getContentDir, getCurrentDir, getDirName, getExtName, getFilteredFileNames, getHomeDir, getObjectFromJSONFile, getPaths, getPlatform, getStringType, getSystemEnvPaths, getTempDir, gradient, isAbsolutePath, isBrowser, isBun, isDeno, isDev, isDirectory, isJsDom, isNode, isPath, isWebWorker, joinPath, joinUrl, line, normalizePath, object2string, prompt, readDir, readFile, relativePath, removeDir, removeDirIfExist, removeFile, removeFileIfExist, removePathIfExist, replacePlaceholders, resolvePath, table, truncate, validateHomeDir, writeFile, writeFileContent };
+export type { Any, AnyArray, AssertEqual, CommonObj, ContentInput, CopyDirOptions, DeepNonNullable, DeepPartial, DeepRequired, EmptyObject, ExpectEqual, FunctionKeys, GetResponse, NonFunctionKeys, NonUndefined, ObjectKeys, ObjectToArray, ObjectValues, Prettify, Response, ReturnAwaitedType, SingleChar };