@shoper/cli 0.1.0-7 → 0.1.0-9

package/build/theme/hooks/theme_checksums/ensure_theme_current_checksums_up_to_date_constants.js

@@ -0,0 +1,7 @@
+import { THEME_COMMANDS_NAME } from '../../commands/theme_commands_constants.js';
+export const THEME_COMMANDS_THAT_REQUIRES_UP_TO_DATE_CHECKSUMS = [
+    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.showChanges,
+    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.verify
+];

package/build/theme/hooks/themes_actions/ensure_themes_actions_hook.js

@@ -0,0 +1,45 @@
+import { useApi } from '../../../cli/hooks/ensure_cli_initialized_hook.js';
+import { THEME_ACTIONS_API_NAME } from '../../features/theme/actions/theme_actions_constants.js';
+import { CLI_AUTH_API_NAME } from '../../../cli/auth/cli_auth_constants.js';
+import { THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST } from './ensure_themes_actions_hook_constants.js';
+import { CLI_AUTH_TOKENS_API_NAME } from '../../../cli/auth/tokens/cli_auth_tokens_constants.js';
+import { promptForToken } from '../../../cli/commands/utils/prompt_for_token_utils.js';
+import { EXECUTION_CONTEXT_API_NAME, EXECUTION_CONTEXTS } from '../../../cli/features/execution_context/execution_context_constants.js';
+const ensureThemesActionsHook = async ({ Command, argv }) => {
+    if (!THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST.includes(Command.id))
+        return;
+    const themesActionsApi = useApi(THEME_ACTIONS_API_NAME);
+    const cliAuthApi = useApi(CLI_AUTH_API_NAME);
+    const executionContextApi = useApi(EXECUTION_CONTEXT_API_NAME);
+    const executionContext = await executionContextApi.getExecutionContext();
+    let themeId = argv[0];
+    if (!themeId && executionContext.type === EXECUTION_CONTEXTS.theme)
+        themeId = executionContext.themeId;
+    const credentials = cliAuthApi.getCredentials();
+    if (!credentials) {
+        console.error('Authorization is required to ensure themes actions.');
+        process.exit(1);
+    }
+    try {
+        await themesActionsApi.ensureThemesActions({
+            credentials,
+            themeId
+        });
+    }
+    catch (err) {
+        if (err.code === 'unauthorized') {
+            console.error('Unauthorized. Please authorize first.');
+            const cliAuthTokensApi = useApi(CLI_AUTH_TOKENS_API_NAME);
+            await promptForToken(cliAuthTokensApi);
+            await themesActionsApi.ensureThemesActions({
+                credentials,
+                themeId
+            });
+        }
+        else {
+            console.error(err);
+            process.exit(1);
+        }
+    }
+};
+export default ensureThemesActionsHook;

package/build/theme/hooks/themes_actions/ensure_themes_actions_hook_constants.js

@@ -0,0 +1,7 @@
+import { THEME_COMMANDS_NAME } from '../../commands/theme_commands_constants.js';
+export const THEME_COMMANDS_THAT_REQUIRED_ACTIONS_LIST = [
+    THEME_COMMANDS_NAME.pull,
+    THEME_COMMANDS_NAME.init,
+    THEME_COMMANDS_NAME.push,
+    THEME_COMMANDS_NAME.showChanges
+];

package/build/theme/index.js

@@ -1,6 +1,15 @@
-import { ThemeListCommand } from './commands/list_command.js';
-import { ThemePullCommand } from './commands/pull_command.js';
+import { ThemeListCommand } from './commands/theme_list_command.js';
+import { ThemePullCommand } from './commands/theme_pull_command.js';
+import { ThemeInitCommand } from './commands/theme_init_command.js';
+import { THEME_COMMANDS_NAME } from './commands/theme_commands_constants.js';
+import { ThemePushCommand } from './commands/theme_push_command.js';
+import { ThemeShowChangesCommand } from './commands/theme_show_changes_command.js';
+import { ThemeVerifyCommand } from './commands/theme_verify_command.js';
 export const COMMANDS = {
-    'theme:list': ThemeListCommand,
-    'theme:pull': ThemePullCommand
+    [THEME_COMMANDS_NAME.list]: ThemeListCommand,
+    [THEME_COMMANDS_NAME.pull]: ThemePullCommand,
+    [THEME_COMMANDS_NAME.init]: ThemeInitCommand,
+    [THEME_COMMANDS_NAME.push]: ThemePushCommand,
+    [THEME_COMMANDS_NAME.showChanges]: ThemeShowChangesCommand,
+    [THEME_COMMANDS_NAME.verify]: ThemeVerifyCommand
 };

package/build/theme/utils/directory_validator/directory_validator_constants.js

@@ -0,0 +1,13 @@
+export const FILES_MODIFICATION_TYPES = {
+    add: 'add',
+    remove: 'remove',
+    edit: 'edit'
+};
+export const DEFAULT_PERMISSION_FOR_ALL_FILES_KEY = '*';
+export const DEFAULT_PERMISSION_FOR_DIRECTORY_KEY = '*/';
+export const PERMISSION_KEY = '__permission__';
+export const DEFAULT_DIRECTORY_STRUCTURE_PERMISSION = {
+    canAdd: false,
+    canEdit: false,
+    canDelete: false
+};

package/build/theme/utils/directory_validator/directory_validator_utils.js

@@ -0,0 +1,185 @@
+import { join, looksLikeDirectory, platformSeparator } from '../../../utils/path_utils.js';
+import { fileExists, getAllFilesAndDirectoriesInside, isDirectory } from '../../../utils/fs/fs_utils.js';
+import uniq from 'lodash/uniq.js';
+import { computeFileChecksum } from '../../../utils/checksums/checksums_utils.js';
+import { DEFAULT_DIRECTORY_STRUCTURE_PERMISSION, DEFAULT_PERMISSION_FOR_ALL_FILES_KEY, DEFAULT_PERMISSION_FOR_DIRECTORY_KEY, FILES_MODIFICATION_TYPES, PERMISSION_KEY } from './directory_validator_constants.js';
+import { CHECKSUM_KEY } from '../../../utils/checksums/checksums_utils_constants.js';
+import _ from 'lodash';
+export const validateDirectory = async ({ rootDirectory, permissions, checksums }) => {
+    const unpermittedActions = [];
+    await _checkPermissions({
+        permissions,
+        permissionPart: permissions,
+        permissionParts: [],
+        parts: [],
+        checksumsPart: checksums,
+        rootDirectory,
+        unpermittedActions
+    });
+    return {
+        isValid: !unpermittedActions.length,
+        unpermittedActions
+    };
+};
+const _checkPermissions = async ({ permissionPart, permissionParts, parts = [], checksumsPart, rootDirectory, unpermittedActions, permissions }) => {
+    if (!permissionPart)
+        return;
+    //TODO required files in a custom module directory
+    const fullPath = join(rootDirectory, ...parts);
+    const filesInsideCurrentDirectory = (await getAllFilesAndDirectoriesInside(fullPath, {
+        recursive: false
+    })).map((file) => (file.isDirectory() ? join(file.name, platformSeparator) : file.name));
+    const files = uniq([
+        ...filesInsideCurrentDirectory,
+        //TODO fix another way
+        ...Object.keys(checksumsPart ?? {}).filter((key) => key !== CHECKSUM_KEY && key !== './')
+    ]);
+    const parentPath = join(...parts);
+    const filesInsideCurrentDirectoryObject = {};
+    filesInsideCurrentDirectory.forEach((path) => {
+        filesInsideCurrentDirectoryObject[path] = true;
+    });
+    for (const file of files) {
+        const { permission, permissionKey } = _getPermission({
+            path: file,
+            fullPath: join(fullPath, file),
+            permissionPart,
+            permissionParts,
+            permissions
+        });
+        if (!permissionKey) {
+            console.log('permission', permission);
+            console.log('parts', parts);
+            console.log('permissionPart', permissionPart);
+            console.log('permissionParts', permissionParts);
+            console.log('permissions', permissions);
+            console.log('file', file);
+            console.log('fullPath', fullPath);
+            // console.log('permission', permission, 'permissionKey', permissionKey);
+        }
+        const action = await _checkPermission({
+            permission: permission[PERMISSION_KEY],
+            path: file,
+            checksumsPart: checksumsPart ?? {},
+            filesInDirectory: filesInsideCurrentDirectoryObject,
+            parentPath,
+            rootDirectory
+        });
+        if (action)
+            unpermittedActions.push(action);
+        if ((await fileExists(join(rootDirectory, join(...parts, file)))) && (await isDirectory(join(fullPath, file)))) {
+            await _checkPermissions({
+                permissionPart: permission,
+                parts: [...parts, file],
+                permissionParts: permissionKey ? [...permissionParts, permissionKey] : permissionParts,
+                checksumsPart: checksumsPart?.[file] ?? {},
+                rootDirectory,
+                unpermittedActions,
+                permissions
+            });
+        }
+    }
+    return;
+};
+const _getPermission = ({ permissions, permissionParts, permissionPart, path, fullPath }) => {
+    const specificPermission = permissionPart[path];
+    const defaultDirectoryPermission = permissionPart[DEFAULT_PERMISSION_FOR_DIRECTORY_KEY];
+    const defaultFilePermission = permissionPart[DEFAULT_PERMISSION_FOR_ALL_FILES_KEY];
+    if (specificPermission)
+        return {
+            permission: specificPermission,
+            permissionKey: path
+        };
+    if (looksLikeDirectory(fullPath) && (defaultDirectoryPermission || defaultFilePermission))
+        return {
+            permission: defaultDirectoryPermission ?? defaultFilePermission,
+            permissionKey: defaultDirectoryPermission ? DEFAULT_PERMISSION_FOR_DIRECTORY_KEY : DEFAULT_PERMISSION_FOR_ALL_FILES_KEY
+        };
+    if (defaultFilePermission) {
+        return {
+            permission: defaultFilePermission,
+            permissionKey: DEFAULT_PERMISSION_FOR_ALL_FILES_KEY
+        };
+    }
+    return _getClosestPermission(permissions, permissionParts);
+};
+const _checkPermission = async ({ permission, path, checksumsPart, filesInDirectory, rootDirectory, parentPath }) => {
+    const relativePath = join(parentPath, path);
+    const fullPath = join(rootDirectory, relativePath);
+    if (!permission.canDelete && !filesInDirectory[path] && checksumsPart[path]) {
+        return {
+            type: FILES_MODIFICATION_TYPES.remove,
+            path,
+            relativePath
+        };
+    }
+    if (!permission.canAdd && filesInDirectory[path] && !checksumsPart[path]) {
+        return {
+            type: FILES_MODIFICATION_TYPES.add,
+            path,
+            relativePath
+        };
+    }
+    if ((await fileExists(fullPath)) && !looksLikeDirectory(join(rootDirectory, path)) && !permission.canEdit && checksumsPart[path]) {
+        const currentChecksum = await computeFileChecksum(fullPath);
+        if (currentChecksum !== checksumsPart[path][CHECKSUM_KEY]) {
+            return {
+                type: FILES_MODIFICATION_TYPES.edit,
+                path,
+                relativePath
+            };
+        }
+    }
+};
+const _getClosestPermission = (permissions, parts) => {
+    if (!parts.length) {
+        return {
+            permission: {
+                [DEFAULT_PERMISSION_FOR_DIRECTORY_KEY]: {
+                    [PERMISSION_KEY]: DEFAULT_DIRECTORY_STRUCTURE_PERMISSION
+                },
+                [DEFAULT_PERMISSION_FOR_ALL_FILES_KEY]: {
+                    [PERMISSION_KEY]: DEFAULT_DIRECTORY_STRUCTURE_PERMISSION
+                }
+            }
+        };
+    }
+    const permissionPart = _.at(permissions, parts.join('.'))?.[0];
+    if (!permissionPart)
+        return _getClosestPermission(permissions, parts.slice(0, -1));
+    if (permissionPart[DEFAULT_PERMISSION_FOR_DIRECTORY_KEY])
+        return {
+            permission: permissionPart[DEFAULT_PERMISSION_FOR_DIRECTORY_KEY],
+            permissionKey: DEFAULT_PERMISSION_FOR_DIRECTORY_KEY
+        };
+    if (permissionPart[DEFAULT_PERMISSION_FOR_ALL_FILES_KEY])
+        return {
+            permission: permissionPart[DEFAULT_PERMISSION_FOR_ALL_FILES_KEY],
+            permissionKey: DEFAULT_PERMISSION_FOR_ALL_FILES_KEY
+        };
+    return _getClosestPermission(permissions, parts.slice(0, -1));
+};
+export const mapToPermissionsTree = (paths) => {
+    const tree = {};
+    Object.entries(paths).forEach(([path, permissions]) => {
+        //TODO Cross platform
+        const parts = path.split('/').filter(Boolean);
+        let currentLevel = tree;
+        parts.forEach((part, index) => {
+            if (index === parts.length - 1) {
+                // TODO cross platform
+                const finalPart = path.endsWith('/') ? `${part}/` : part;
+                if (!currentLevel[finalPart])
+                    currentLevel[finalPart] = {};
+                currentLevel[finalPart][PERMISSION_KEY] = { ...permissions };
+            }
+            if (index !== parts.length - 1) {
+                const finalPart = `${part}/`;
+                if (!currentLevel[finalPart])
+                    currentLevel[finalPart] = {};
+                currentLevel = currentLevel[finalPart];
+            }
+        });
+    });
+    return tree;
+};

package/build/utils/checksums/checksums_utils.js

@@ -0,0 +1,95 @@
+import crypto, { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { dirname, join, platformSeparator, relative } from '../path_utils.js';
+import klaw from 'klaw';
+import { CHECKSUM_KEY } from './checksums_utils_constants.js';
+export const computeChecksum = (data, algorithm = 'md5') => {
+    const hash = crypto.createHash(algorithm);
+    hash.update(data);
+    return hash.digest('hex');
+};
+export const computeFileChecksum = async (filePath, algorithm = 'md5') => {
+    return new Promise((resolve, reject) => {
+        const hash = createHash(algorithm);
+        const stream = createReadStream(filePath);
+        stream.on('data', (data) => {
+            hash.update(data);
+        });
+        stream.on('close', () => {
+            resolve(hash.digest('hex'));
+        });
+        stream.on('error', (err) => {
+            reject(err);
+        });
+    });
+};
+export const computeChecksumsFromSource = (source) => {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        klaw(source)
+            .on('data', (item) => {
+            if (!item.stats.isDirectory())
+                files.push(item.path);
+        })
+            .on('end', () => {
+            computeChecksumsFromFilesStructure(files, source).then(({ filesChecksumsInDirectories, filesChecksums }) => {
+                resolve({ ...filesChecksums, ...computeDirectoriesChecksums(filesChecksumsInDirectories) });
+            });
+        });
+    });
+};
+export const computeChecksumsFromFilesStructure = async (files, rootDir) => {
+    const filesChecksums = {};
+    const filesChecksumsInDirectories = {};
+    for (const filePath of files) {
+        const checksum = await computeFileChecksum(filePath);
+        const relativePath = relative(rootDir, filePath);
+        filesChecksums[relativePath] = checksum;
+        const zipDir = join(dirname(relativePath), platformSeparator);
+        const zipParts = zipDir.split(platformSeparator);
+        zipParts.pop();
+        const currentParts = [];
+        zipParts.forEach((part) => {
+            currentParts.push(part);
+            const partsDir = join(...currentParts, platformSeparator);
+            if (!filesChecksumsInDirectories[partsDir])
+                filesChecksumsInDirectories[partsDir] = [];
+            filesChecksumsInDirectories[partsDir].push(checksum);
+        });
+    }
+    return {
+        filesChecksums,
+        filesChecksumsInDirectories
+    };
+};
+export const computeDirectoriesChecksums = (filesChecksumsInDirectories) => {
+    const checksums = {};
+    Object.entries(filesChecksumsInDirectories).forEach(([directoryPath, filesChecksums]) => {
+        checksums[directoryPath] = computeChecksum(filesChecksums.sort().join(''));
+    });
+    return checksums;
+};
+export const mapChecksumToTree = (checksums) => {
+    const tree = {};
+    Object.entries(checksums).forEach(([path, checksum]) => {
+        const parts = path.split(platformSeparator).filter(Boolean);
+        let currentLevel = tree;
+        parts.filter(Boolean).forEach((part, index) => {
+            if (index === parts.length - 1) {
+                // TODO cross platform
+                const finalPart = path.endsWith('/') ? `${part}/` : part;
+                if (!currentLevel[finalPart])
+                    currentLevel[finalPart] = {};
+                currentLevel[finalPart][CHECKSUM_KEY] = checksum;
+            }
+            if (index !== parts.length - 1) {
+                // TODO cross platform
+                const finalPart = `${part}/`;
+                if (!currentLevel[finalPart])
+                    currentLevel[finalPart] = {};
+                currentLevel = currentLevel[finalPart];
+            }
+        });
+    });
+    return tree;
+};

package/build/utils/checksums/checksums_utils_constants.js

@@ -0,0 +1 @@
+export const CHECKSUM_KEY = '__checksum__';

package/build/utils/date_utils.js

@@ -0,0 +1,3 @@
+export const getNMinutesFromNow = (n) => {
+    return Date.now() + n * 60 * 1000;
+};

package/build/utils/download_file/download_file_errors_factory.js

@@ -0,0 +1,9 @@
+import { AppError } from '../../cli/class/errors/app_error/app_error.js';
+export class DownloadFileErrorsFactory {
+    static downloadError(status) {
+        return new AppError({
+            message: 'Download error',
+            code: status ?? 'download_error'
+        });
+    }
+}

package/build/utils/download_file/download_file_utils.js

@@ -0,0 +1,46 @@
+import { getFileNameFromHeaders } from '../http_utils.js';
+import { createWriteStream } from 'fs';
+import { URL } from 'url';
+import { basename, extname, join, parse } from '../path_utils.js';
+import { FileSystemErrorsFactory } from '../../cli/class/errors/file_system_errors_factory.js';
+import { HttpErrorsFactory } from '../../cli/class/errors/http_errors_factory.js';
+import { DownloadFileErrorsFactory } from './download_file_errors_factory.js';
+export const downloadFile = async ({ dist, request }) => {
+    try {
+        const resp = (await request);
+        const headers = resp.headers;
+        const url = new URL(resp.config.url);
+        const filename = getFileNameFromHeaders(headers) ?? basename(url.pathname);
+        const file = createWriteStream(join(dist, filename));
+        resp.data.pipe(file);
+        return new Promise((resolve, reject) => {
+            file.on('finish', () => {
+                resolve({
+                    filename,
+                    ext: extname(filename),
+                    basename: parse(filename).name
+                });
+            });
+            file.on('error', (err) => {
+                if (err.code === 'ENOSPC')
+                    reject(FileSystemErrorsFactory.createDiskFullError());
+                reject(DownloadFileErrorsFactory.downloadError(err.response.status));
+            });
+        });
+    }
+    catch (err) {
+        switch (err.response?.status) {
+            case 403:
+                throw HttpErrorsFactory.createForbiddenError();
+            case 401:
+                throw HttpErrorsFactory.createUnauthorizedError();
+            case 404:
+                throw HttpErrorsFactory.createNotFoundError();
+            default:
+                if (err.response?.status !== 200) {
+                    throw DownloadFileErrorsFactory.downloadError(err.response.status);
+                }
+        }
+    }
+    throw DownloadFileErrorsFactory.downloadError('Unknown error');
+};

package/build/utils/fs/errors/stream_read_error.js

@@ -0,0 +1,11 @@
+import { AppError } from '../../../cli/class/errors/app_error/app_error.js';
+export class StreamReadError extends AppError {
+    constructor({ filePath, details, stack }) {
+        super({
+            code: 'STREAM_READ_ERROR',
+            message: `Error while reading stream for file: ${filePath}`,
+            details,
+            stack
+        });
+    }
+}

package/build/utils/fs/errors/stream_write_error.js

@@ -0,0 +1,11 @@
+import { AppError } from '../../../cli/class/errors/app_error/app_error.js';
+export class StreamWriteError extends AppError {
+    constructor({ filePath, details, stack }) {
+        super({
+            code: 'STREAM_WRITE_ERROR',
+            message: `Error while writing to stream for file: ${filePath}`,
+            details,
+            stack
+        });
+    }
+}

package/build/utils/fs/fs_utils.js

@@ -0,0 +1,155 @@
+import fsPromises from 'node:fs/promises';
+import fs, { createReadStream } from 'node:fs';
+import { isHiddenFile } from 'is-hidden-file';
+import process from 'node:process';
+import { basename, join, resolve } from '../path_utils.js';
+import { parse as parsePath } from 'node:path';
+import { FileSystemErrorsFactory } from '../../cli/class/errors/file_system_errors_factory.js';
+import { JSON_FILE_INDENT } from '../../cli/cli_constants.js';
+import tmp from 'tmp-promise';
+import { pipeline } from 'node:stream/promises';
+import { jsonIndentTransform } from '../stream_transforms/json_indent_transform.js';
+import { move } from 'fs-extra';
+export const fileExists = async (path) => {
+    try {
+        await fsPromises.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const directoryExists = async (path) => {
+    return fileExists(path);
+};
+export const readFile = async (path, options) => {
+    return fsPromises.readFile(path, options);
+};
+export const writeFile = async (path, data, options) => {
+    return fsPromises.writeFile(path, data, options);
+};
+export const readJSONFile = async (path, options = { encoding: 'utf-8', flag: 'r' }) => {
+    const fileContent = await readFile(path, options);
+    if (typeof fileContent !== 'string')
+        throw new Error('File content is not a string');
+    try {
+        return JSON.parse(fileContent);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON from file ${path}: ${error}`);
+    }
+};
+export const writeJSONFile = async (path, data) => {
+    try {
+        await writeFile(path, JSON.stringify(data, null, JSON_FILE_INDENT), {
+            encoding: 'utf-8',
+            flag: 'w'
+        });
+    }
+    catch (error) {
+        throw new Error(`Failed to write JSON to file ${path}: ${error}`);
+    }
+};
+export const formatJSONFile = async (path, indent = JSON_FILE_INDENT) => {
+    const { path: tmpDir, cleanup } = await tmp.dir({ unsafeCleanup: true });
+    const fileName = basename(path);
+    const formattedTmpFilePath = join(tmpDir, fileName);
+    const readStream = createReadStream(path);
+    const writeStream = fs.createWriteStream(formattedTmpFilePath);
+    await pipeline(readStream, jsonIndentTransform(indent), writeStream);
+    // await copyFile(formattedTmpFilePath, path, { force: true });
+    await move(formattedTmpFilePath, path, { overwrite: true });
+    await cleanup();
+};
+export const openFile = async (path, flags, mode) => {
+    return fsPromises.open(path, flags, mode);
+};
+export const makeDirectory = async (path, options = {}) => {
+    return await fsPromises.mkdir(path, { recursive: false, ...options });
+};
+export const removeDirectory = async (path, options = {}) => {
+    return removeFile(path, options);
+};
+export const removeDirectorySync = (path, options = {}) => {
+    return removeFileSync(path, { recursive: true, force: true, ...options });
+};
+export const removeFileSync = (path, options = {}) => {
+    return fs.rmSync(path, { recursive: true, force: true, ...options });
+};
+export const removeFiles = async (files, options = {}) => {
+    return Promise.all(files.map((file) => removeFile(file, options)));
+};
+export const removeFile = async (path, options = {}) => {
+    return fsPromises.rm(path, { recursive: true, force: true, ...options });
+};
+export const getAllFilesAndDirectoriesInside = async (path, options) => {
+    const { recursive = true, withFileTypes = true } = options ?? {};
+    return await fsPromises.readdir(path, {
+        recursive,
+        withFileTypes
+    });
+};
+export const getAllDirectoriesNamesInside = async (path, options) => {
+    const { recursive = true, hidden = true } = options;
+    const files = await fsPromises.readdir(path, {
+        recursive,
+        withFileTypes: true
+    });
+    return files.filter((file) => file.isDirectory() && (hidden ? true : !isHiddenFile(file.name))).map((file) => file.name);
+};
+export const getAllFilesNamesInside = async (path, options = {}) => {
+    const { recursive = true, hidden = true } = options ?? {};
+    const files = await fsPromises.readdir(path, {
+        recursive,
+        withFileTypes: true
+    });
+    return files.filter((file) => !file.isDirectory() && (hidden ? true : !isHiddenFile(file.name))).map((file) => file.name);
+};
+export const closestFile = async (fileToFind, path = process.cwd()) => {
+    let currPath = path;
+    const rootDir = getOSRootDirectory();
+    while (currPath !== rootDir) {
+        const exists = await fileExists(resolve(currPath, fileToFind));
+        if (exists)
+            return currPath;
+        currPath = resolve(currPath, '..');
+    }
+};
+export const closestDirectory = async (path) => {
+    return closestFile(path);
+};
+export const getOSRootDirectory = () => parsePath(process.cwd()).root;
+export const isDirectory = async (path) => {
+    const stats = await fsPromises.stat(path);
+    return stats.isDirectory();
+};
+export const copyFile = async (source, destination, options = {
+    force: true,
+    recursive: true
+}) => {
+    try {
+        await fsPromises.cp(source, destination, options);
+    }
+    catch (err) {
+        throw FileSystemErrorsFactory.createErrorCopyingFile(source, destination, err);
+    }
+};
+export const copyFileSync = (source, destination, options = {
+    force: true,
+    recursive: true
+}) => {
+    try {
+        fs.cpSync(source, destination, options);
+    }
+    catch (err) {
+        throw FileSystemErrorsFactory.createErrorCopyingFile(source, destination, err);
+    }
+};
+export const renameFile = async (source, destination) => {
+    try {
+        await fsPromises.rename(source, destination);
+    }
+    catch (err) {
+        throw FileSystemErrorsFactory.createErrorMovingFile(source, destination, err);
+    }
+};

package/build/utils/http_utils.js

@@ -0,0 +1,10 @@
+export const getFileNameFromHeaders = (headers) => {
+    const contentDisposition = headers['content-disposition'];
+    if (!contentDisposition)
+        return;
+    const matches = contentDisposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+    if (!matches || !matches[1])
+        return;
+    const filename = matches[1].replace(/['"]/g, '');
+    return decodeURIComponent(filename);
+};

package/build/utils/path_utils.js

@@ -0,0 +1,37 @@
+import { basename as pathBaseName, dirname as pathDirname, extname as pathExtname, join as pathJoin, normalize, parse as parsePath, relative as pathRelative, resolve as resolvePath, sep } from 'node:path';
+import fs from 'node:fs';
+export const resolve = (...paths) => {
+    return resolvePath(...paths);
+};
+export const parse = (path) => {
+    return parsePath(path);
+};
+export const join = (...paths) => {
+    return pathJoin(...paths);
+};
+export const relative = (from, to) => {
+    return pathRelative(from, to);
+};
+export const basename = (path, ext) => pathBaseName(path, ext);
+export const dirname = (path) => pathDirname(path);
+export const extname = (path) => pathExtname(path);
+export const hasParentDirectory = (path) => {
+    return dirname(path) !== '.';
+};
+export const looksLikeDirectory = (path) => {
+    const normalized = normalize(path);
+    if (normalized.endsWith(sep))
+        return true;
+    const base = basename(normalized);
+    const isHidden = base.startsWith('.') && !base.slice(1).includes('.');
+    const hasExtension = base.slice(1).includes('.');
+    if (isHidden) {
+        const stat = fs.lstatSync(path);
+        return stat.isDirectory();
+    }
+    return isHidden || !hasExtension;
+};
+export const toUnixPath = (filePath) => {
+    return normalize(filePath).replace(/\\/g, '/');
+};
+export const platformSeparator = sep;