Compare commits
No commits in common. "master" and "v11.0.9" have entirely different histories.
357
changelog.md
357
changelog.md
@ -1,357 +0,0 @@
|
||||
# Changelog
|
||||
|
||||
## 2025-01-29 - 11.2.0 - feat(fs)
|
||||
Enhanced copy method with optional replaceTargetDir option for directory replacement
|
||||
|
||||
- Added optional 'replaceTargetDir' option to 'copy' and 'copySync' methods in 'fs.ts'.
|
||||
- The 'replaceTargetDir' option allows replacing the target directory if both source and target are directories.
|
||||
|
||||
## 2025-01-29 - 11.1.9 - fix(fs)
|
||||
Fix directory handling in copy and copySync functions
|
||||
|
||||
- Ensured existing directories at destination are removed before copying over them in async copy.
|
||||
- Added a similar check and handling for synchronous copySync when destination is a directory.
|
||||
|
||||
## 2025-01-29 - 11.1.8 - fix(fs)
|
||||
Fixed copy and copySync functions to ensure they always overwrite files.
|
||||
|
||||
- Fixed bug in copy function where files were not being overwritten when they already existed at the destination.
|
||||
- Fixed bug in copySync function to ensure files are overwritten to match the async function's behavior.
|
||||
|
||||
## 2025-01-29 - 11.1.7 - fix(fs)
|
||||
Refactor copy and copySync functions to simplify return type
|
||||
|
||||
- Changed the return type of fs.copy and fs.copySync from boolean to void.
|
||||
- Removed unnecessary promise handling in fs.copy.
|
||||
|
||||
## 2025-01-29 - 11.1.6 - fix(fs)
|
||||
Fix issues with fs file copy functions.
|
||||
|
||||
- Updated dependencies in package.json.
|
||||
- Corrected comments for asynchronous and synchronous file copy functions in fs.ts.
|
||||
|
||||
## 2025-01-07 - 11.1.5 - fix(fs)
|
||||
Improve waitForFileToBeReady function to handle directories and file stabilization
|
||||
|
||||
- Enhanced the waitForFileToBeReady to handle directory paths by checking for file existence within directories and waiting for stabilization.
|
||||
- Modified the watcher logic to cater to changes when monitoring directories for file appearance.
|
||||
- Introduced a helper function to ensure paths exist and another to resolve the first file in directories.
|
||||
- Corrected logic for polling and stabilizing files within directories.
|
||||
|
||||
## 2025-01-07 - 11.1.4 - fix(fs)
|
||||
Fix file existence check in waitForFileToBeReady method.
|
||||
|
||||
- Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
|
||||
- Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
|
||||
- Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
|
||||
|
||||
## 2025-01-07 - 11.1.3 - fix(fs)
|
||||
Fix TypeScript type issue in fs module
|
||||
|
||||
- Corrected a TypeScript type in the fs module's checkFileStability function.
|
||||
|
||||
## 2025-01-07 - 11.1.2 - fix(fs)
|
||||
Fix issues in file stability check and directory existence verification in fs module
|
||||
|
||||
- Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
|
||||
- Fixed logic for ensuring the target directory exists before setting up file stability watcher.
|
||||
- Refactored directory existence logic into 'ensureDirectoryExists' function.
|
||||
|
||||
## 2025-01-07 - 11.1.1 - fix(fs)
|
||||
Improve waitForFileToBeReady function for file stability detection
|
||||
|
||||
- Enhanced error handling and file stability checks in waitForFileToBeReady function
|
||||
- Added timeout feature for file readiness check
|
||||
- Improved directory access check before file availability check
|
||||
|
||||
## 2025-01-07 - 11.1.0 - feat(SmartFile)
|
||||
Add rename functionality to SmartFile class
|
||||
|
||||
- Implemented a new method to rename a file within the SmartFile class.
|
||||
- The rename method updates the file path and optionally writes the renamed file to the disk.
|
||||
|
||||
## 2024-12-15 - 11.0.23 - fix(fs)
|
||||
Handle errors in toObjectSync method
|
||||
|
||||
- Added error handling in toObjectSync function to capture and provide more informative error messages.
|
||||
|
||||
## 2024-06-23 - 11.0.22 - fix(core)
|
||||
Update dependencies and changelog
|
||||
|
||||
- Updated @push.rocks/smartstream to ^3.0.44
|
||||
- Updated glob to ^10.4.2
|
||||
- Updated @types/node to ^20.14.8
|
||||
|
||||
## 2024-06-23 - 11.0.21 - fix(dependencies)
|
||||
Update dependencies to latest versions
|
||||
|
||||
- Updated @push.rocks/smartpromise to ^4.0.4
|
||||
- Updated @push.rocks/smartstream to ^3.0.44
|
||||
- Updated glob to ^10.4.2
|
||||
- Updated @types/node to ^20.14.8
|
||||
|
||||
## 2024-06-07 - 11.0.20 - Changelog
|
||||
11.0.20
|
||||
|
||||
## 2024-06-07 - 11.0.19 - fix(core): update
|
||||
11.0.19
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-06-07 - 11.0.18 - fix(core): update
|
||||
11.0.18
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-06-06 - 11.0.17 - fix(core): update
|
||||
11.0.17
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-06-06 - 11.0.16 - fix(core): update
|
||||
11.0.16
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-05-29 - 11.0.16 - update description
|
||||
11.0.16
|
||||
|
||||
- update description
|
||||
|
||||
## 2024-05-17 - 11.0.15 - fix(core): update
|
||||
11.0.15
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-14 - 11.0.14 - update tsconfig
|
||||
11.0.14
|
||||
|
||||
- update tsconfig
|
||||
|
||||
## 2024-04-12 - 11.0.13 - fix(core): update
|
||||
11.0.13
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-12 - 11.0.12 - fix(core): update
|
||||
11.0.12
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-12 - 11.0.11 - fix(core): update
|
||||
11.0.11
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-03 - 11.0.10 - fix(core): update
|
||||
11.0.10
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-03 - 11.0.9 - fix(core): update
|
||||
11.0.9
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-02 - 11.0.8 - fix(core): update
|
||||
11.0.8
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-02 - 11.0.7 - fix(core): update
|
||||
11.0.7
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-02 - 11.0.6 - fix(core): update
|
||||
11.0.6
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2024-04-01 - 11.0.5 - update npmextra.json
|
||||
11.0.5
|
||||
|
||||
- update npmextra.json: githost
|
||||
|
||||
## 2024-04-01 - 11.0.4 - fix(core): update
|
||||
11.0.4
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-24 - 11.0.3 - fix(core): update
|
||||
11.0.3
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-07 - 11.0.2 - fix(core): update
|
||||
11.0.2
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-07 - 11.0.1 - fix(core): update
|
||||
11.0.1
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-06 - 11.0.0 - fix(core): update
|
||||
11.0.0
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
|
||||
10.0.40
|
||||
|
||||
- BREAKING CHANGE(core): update
|
||||
|
||||
## 2023-11-04 - 10.0.39 - fix(core): update
|
||||
10.0.39
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-04 - 10.0.38 - fix(core): update
|
||||
10.0.38
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-04 - 10.0.37 - fix(core): update
|
||||
10.0.37
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-03 - 10.0.36 - fix(core): update
|
||||
10.0.36
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-03 - 10.0.35 - fix(core): update
|
||||
10.0.35
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-03 - 10.0.34 - fix(core): update
|
||||
10.0.34
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-11-03 - 10.0.33 - fix(core): update
|
||||
10.0.33
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-10-12 - 10.0.32 - fix(core): update
|
||||
10.0.32
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-09-22 - 10.0.31 - fix(core): update
|
||||
10.0.31
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-08-31 - 10.0.30 - fix(core): update
|
||||
10.0.30
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-08-23 - 10.0.29 - fix(core): update
|
||||
10.0.29
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-07-12 - 10.0.28 - fix(core): update
|
||||
10.0.28
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-07-10 - 10.0.27 - fix(core): update
|
||||
10.0.27
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-07-10 - 10.0.26 - fix(core): update
|
||||
10.0.26
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-07-08 - 10.0.25 - fix(core): update
|
||||
10.0.25
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
|
||||
10.0.24 to 10.0.14
|
||||
|
||||
- Series of fixes in the core module
|
||||
|
||||
## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
|
||||
10.0.13 to 10.0.6
|
||||
|
||||
- Series of fixes in the core module
|
||||
|
||||
## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
|
||||
10.0.5 to 10.0.3
|
||||
|
||||
- Series of fixes in the core module
|
||||
|
||||
## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
|
||||
10.0.2 to 10.0.1
|
||||
|
||||
- Series of fixes in the core module
|
||||
|
||||
## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
|
||||
9.0.7
|
||||
|
||||
- BREAKING CHANGE(core): switch to esm
|
||||
|
||||
## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
|
||||
9.0.6 to 9.0.2
|
||||
|
||||
- Series of fixes in the core module
|
||||
|
||||
## 2021-12-01 - 9.0.1 - fix(core): update
|
||||
9.0.1
|
||||
|
||||
- fix(core): update
|
||||
|
||||
## 2021-12-01 - 9.0.0 - fix(absolute pathing)
|
||||
9.0.0
|
||||
|
||||
- add functions for easily getting absolute paths
|
||||
|
||||
## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
|
||||
8.0.11
|
||||
|
||||
- improved relative pathing
|
||||
|
||||
## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
|
||||
8.0.10 to 7.0.12
|
||||
|
||||
- Series of fixes in the core module
|
||||
- BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
|
||||
|
||||
## 2019-02-17 - 7.0.0 - fix(core): update dependencies
|
||||
7.0.0
|
||||
|
||||
- fix(core): update dependencies
|
||||
|
||||
## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
|
||||
6.0.12
|
||||
|
||||
- now returns a Promise<boolean>
|
||||
|
||||
## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
|
||||
6.0.11 to 6.0.6
|
||||
|
||||
- Series of fixes in core and dependencies
|
||||
|
||||
## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
|
||||
6.0.5 to 5.0.0
|
||||
|
||||
- Series of fixes in core and dependencies
|
||||
|
||||
## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
|
||||
4.2.28
|
||||
|
||||
- switch to pushrocks scope
|
||||
|
||||
|
||||
@ -10,28 +10,22 @@
|
||||
"githost": "code.foss.global",
|
||||
"gitscope": "push.rocks",
|
||||
"gitrepo": "smartfile",
|
||||
"description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
|
||||
"description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
|
||||
"npmPackagename": "@push.rocks/smartfile",
|
||||
"license": "MIT",
|
||||
"keywords": [
|
||||
"file management",
|
||||
"files management",
|
||||
"TypeScript",
|
||||
"Node.js",
|
||||
"file operations",
|
||||
"file manipulation",
|
||||
"file streaming",
|
||||
"virtual directory",
|
||||
"filesystem utilities",
|
||||
"memory-efficient file handling",
|
||||
"custom file operations",
|
||||
"write files",
|
||||
"read files",
|
||||
"write files",
|
||||
"copy files",
|
||||
"delete files",
|
||||
"list directories",
|
||||
"handle large files",
|
||||
"virtual filesystems",
|
||||
"buffer operations"
|
||||
"file streaming",
|
||||
"directories manipulation",
|
||||
"virtual file system",
|
||||
"filesystem utilities",
|
||||
"ESM syntax",
|
||||
"memory-efficient streaming"
|
||||
]
|
||||
}
|
||||
},
|
||||
|
||||
58
package.json
58
package.json
@ -1,8 +1,8 @@
|
||||
{
|
||||
"name": "@push.rocks/smartfile",
|
||||
"private": false,
|
||||
"version": "11.2.0",
|
||||
"description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
|
||||
"version": "11.0.9",
|
||||
"description": "provides a robust suite of tools for managing files in Node.js using TypeScript.",
|
||||
"main": "dist_ts/index.js",
|
||||
"typings": "dist_ts/index.d.ts",
|
||||
"type": "module",
|
||||
@ -13,58 +13,52 @@
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://code.foss.global/push.rocks/smartfile.git"
|
||||
"url": "git+https://gitlab.com/push.rocks/smartfile.git"
|
||||
},
|
||||
"keywords": [
|
||||
"file management",
|
||||
"files management",
|
||||
"TypeScript",
|
||||
"Node.js",
|
||||
"file operations",
|
||||
"file manipulation",
|
||||
"file streaming",
|
||||
"virtual directory",
|
||||
"filesystem utilities",
|
||||
"memory-efficient file handling",
|
||||
"custom file operations",
|
||||
"write files",
|
||||
"read files",
|
||||
"write files",
|
||||
"copy files",
|
||||
"delete files",
|
||||
"list directories",
|
||||
"handle large files",
|
||||
"virtual filesystems",
|
||||
"buffer operations"
|
||||
"file streaming",
|
||||
"directories manipulation",
|
||||
"virtual file system",
|
||||
"filesystem utilities",
|
||||
"ESM syntax",
|
||||
"memory-efficient streaming"
|
||||
],
|
||||
"author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://gitlab.com/push.rocks/smartfile/issues"
|
||||
},
|
||||
"homepage": "https://code.foss.global/push.rocks/smartfile",
|
||||
"homepage": "https://gitlab.com/push.rocks/smartfile#readme",
|
||||
"dependencies": {
|
||||
"@push.rocks/lik": "^6.1.0",
|
||||
"@push.rocks/lik": "^6.0.12",
|
||||
"@push.rocks/smartdelay": "^3.0.5",
|
||||
"@push.rocks/smartfile-interfaces": "^1.0.7",
|
||||
"@push.rocks/smarthash": "^3.0.4",
|
||||
"@push.rocks/smartjson": "^5.0.20",
|
||||
"@push.rocks/smartmime": "^2.0.4",
|
||||
"@push.rocks/smartpath": "^5.0.18",
|
||||
"@push.rocks/smartpromise": "^4.2.2",
|
||||
"@push.rocks/smartrequest": "^2.0.23",
|
||||
"@push.rocks/smartstream": "^3.2.5",
|
||||
"@push.rocks/smartjson": "^5.0.10",
|
||||
"@push.rocks/smartmime": "^1.0.5",
|
||||
"@push.rocks/smartpath": "^5.0.11",
|
||||
"@push.rocks/smartpromise": "^4.0.2",
|
||||
"@push.rocks/smartrequest": "^2.0.21",
|
||||
"@push.rocks/smartstream": "^3.0.30",
|
||||
"@types/fs-extra": "^11.0.4",
|
||||
"@types/glob": "^8.1.0",
|
||||
"@types/js-yaml": "^4.0.9",
|
||||
"fs-extra": "^11.3.0",
|
||||
"glob": "^11.0.1",
|
||||
"fs-extra": "^11.1.1",
|
||||
"glob": "^10.3.10",
|
||||
"js-yaml": "^4.1.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@git.zone/tsbuild": "^2.2.1",
|
||||
"@git.zone/tsrun": "^1.3.3",
|
||||
"@git.zone/tstest": "^1.0.96",
|
||||
"@push.rocks/tapbundle": "^5.5.6",
|
||||
"@types/node": "^22.12.0"
|
||||
"@git.zone/tsbuild": "^2.1.70",
|
||||
"@git.zone/tsrun": "^1.2.46",
|
||||
"@git.zone/tstest": "^1.0.84",
|
||||
"@push.rocks/tapbundle": "^5.0.15",
|
||||
"@types/node": "^20.10.0"
|
||||
},
|
||||
"files": [
|
||||
"ts/**/*",
|
||||
|
||||
11969
pnpm-lock.yaml
generated
11969
pnpm-lock.yaml
generated
File diff suppressed because it is too large
Load Diff
@ -1 +0,0 @@
|
||||
|
||||
217
readme.md
217
readme.md
@ -1,6 +1,6 @@
|
||||
# @push.rocks/smartfile
|
||||
|
||||
> Provides a robust suite of tools for managing files in Node.js using TypeScript.
|
||||
> offers smart ways to work with files in nodejs
|
||||
|
||||
## Install
|
||||
|
||||
@ -12,214 +12,87 @@ npm install @push.rocks/smartfile
|
||||
|
||||
## Usage
|
||||
|
||||
`@push.rocks/smartfile` offers extensive file management utilities, enabling seamless file processing with TypeScript in a Node.js environment. Below are detailed examples showcasing various features of the module.
|
||||
`@push.rocks/smartfile` provides a robust suite of tools for managing files in Node.js projects using modern TypeScript and ESM syntax. It simplifies numerous file operations such as reading, writing, copying, and streaming files, as well as working with directories and virtual file systems.
|
||||
|
||||
### Quick Start
|
||||
### **Key Features and Classes**
|
||||
|
||||
First, ensure you're working in an environment that supports ECMAScript modules (ESM) and TypeScript. Here’s how you’d generally import and use `@push.rocks/smartfile`:
|
||||
- **`SmartFile`**: Facilitates reading from and writing to individual files, managing metadata.
|
||||
- **`StreamFile`**: Optimizes memory usage by enabling efficient file streaming.
|
||||
- **`VirtualDirectory`**: Allows manipulation of a group of files or directories as a virtual file system.
|
||||
|
||||
### **Getting Started with ESM and TypeScript**
|
||||
|
||||
First, ensure your project supports ESM syntax and TypeScript. Then, begin by importing the desired features from `@push.rocks/smartfile`:
|
||||
|
||||
```typescript
|
||||
import { SmartFile, StreamFile, VirtualDirectory, fs, memory, interpreter } from '@push.rocks/smartfile';
|
||||
import { SmartFile, StreamFile, VirtualDirectory, memory, fs as smartFs } from '@push.rocks/smartfile';
|
||||
```
|
||||
|
||||
### Working with `SmartFile`
|
||||
### **Reading and Writing Files**
|
||||
|
||||
#### Reading Files
|
||||
|
||||
To read from a file and convert it to a `SmartFile` instance:
|
||||
Reading a JSON file:
|
||||
|
||||
```typescript
|
||||
const myJsonSmartFile: SmartFile = await SmartFile.fromFilePath('./somePath/data.json');
|
||||
const jsonData = JSON.parse(myJsonSmartFile.contents.toString());
|
||||
console.log(jsonData); // Assuming the file contains JSON content
|
||||
const myJsonFile: SmartFile = await SmartFile.fromFilePath('./data.json');
|
||||
const jsonData = JSON.parse(myJsonFile.contents.toString());
|
||||
console.log(jsonData);
|
||||
```
|
||||
|
||||
#### Writing Files
|
||||
|
||||
To write data to a file through a `SmartFile`:
|
||||
Writing content to a file:
|
||||
|
||||
```typescript
|
||||
const filePath: string = './output/outputData.json';
|
||||
const content: string = JSON.stringify({ key: 'value' });
|
||||
const filePath: string = './output.txt';
|
||||
const content: string = 'Hello, SmartFile!';
|
||||
await memory.toFs(content, filePath);
|
||||
console.log('File saved successfully.');
|
||||
```
|
||||
|
||||
### Streaming Large Files with `StreamFile`
|
||||
### **Streaming Large Files**
|
||||
|
||||
When dealing with large files, you can use `StreamFile` to handle such files efficiently, minimizing memory usage:
|
||||
For large files, `StreamFile` provides a memory-efficient streaming solution:
|
||||
|
||||
```typescript
|
||||
const largeFile: StreamFile = await StreamFile.fromPath('./largeInput/largeFile.mp4');
|
||||
await largeFile.writeToDisk('./largeOutput/largeFileCopy.mp4');
|
||||
import { createReadStream } from 'fs';
|
||||
|
||||
const sourceStream = createReadStream('./large-video.mp4');
|
||||
const myStreamFile = await StreamFile.fromStream(sourceStream, 'large-video.mp4');
|
||||
await myStreamFile.writeToDir('./storage');
|
||||
console.log('Large file streamed to disk successfully.');
|
||||
```
|
||||
|
||||
### Working with Virtual Directories
|
||||
### **Working with Virtual Directories**
|
||||
|
||||
Handling multiple files as if they were part of a file system:
|
||||
`VirtualDirectory` abstracts a collection of files allowing operations to be performed as if they were on disk:
|
||||
|
||||
```typescript
|
||||
const virtualDir = await VirtualDirectory.fromFsDirPath('./data/inputDir');
|
||||
await virtualDir.saveToDisk('./data/outputDir');
|
||||
const virtualDir = new VirtualDirectory();
|
||||
virtualDir.addSmartfiles([smartFile1, smartFile2]); // Assuming these are SmartFile instances
|
||||
await virtualDir.saveToDisk('./virtual-output');
|
||||
console.log('Virtual directory saved to disk.');
|
||||
```
|
||||
|
||||
### File System Operations
|
||||
### **Advanced File Operations**
|
||||
|
||||
`@push.rocks/smartfile` provides a suite of utilities for common file system operations such as copying, deleting, and listing files or directories.
|
||||
`@push.rocks/smartfile` simplifies complex file operations, including:
|
||||
|
||||
#### Copying a File
|
||||
- Copying directories and files
|
||||
- Removing files or directories
|
||||
- Listing files and directories with filters
|
||||
- Reading file content directly into JavaScript objects
|
||||
|
||||
```typescript
|
||||
await fs.copy('./sourceFile.txt', './destinationFile.txt');
|
||||
```
|
||||
### **Web File Handling**
|
||||
|
||||
#### Deleting a Directory
|
||||
Handling files from HTTP requests:
|
||||
|
||||
```typescript
|
||||
await fs.remove('./directoryToDelete');
|
||||
```
|
||||
`@push.rocks/smartfile` offers utilities to work with files from web sources, making it simpler to manage downloads and uploads.
|
||||
|
||||
#### Listing Files in a Directory
|
||||
### **Comprehensive File Management**
|
||||
|
||||
```typescript
|
||||
const fileList: string[] = await fs.listFiles('./someDirectory');
|
||||
console.log(fileList);
|
||||
```
|
||||
|
||||
### Advanced File Management
|
||||
|
||||
For specialized file operations, such as editing the contents of a file or streaming files from URLs, `@push.rocks/smartfile` includes advanced management features.
|
||||
|
||||
#### Editing a File’s Contents
|
||||
|
||||
```typescript
|
||||
const smartFileToEdit: SmartFile = await SmartFile.fromFilePath('./editableFile.txt');
|
||||
await smartFileToEdit.editContentAsString(async (content) => content.replace(/originalText/g, 'newText'));
|
||||
await smartFileToEdit.write();
|
||||
```
|
||||
|
||||
#### Streaming a File from a URL
|
||||
|
||||
```typescript
|
||||
const streamedFile: StreamFile = await StreamFile.fromUrl('https://example.com/file.pdf');
|
||||
await streamedFile.writeToDisk('./downloadedFiles/file.pdf');
|
||||
```
|
||||
|
||||
### Working with File Buffers and Streams
|
||||
|
||||
`@push.rocks/smartfile` allows you to easily work with files using Buffers and Streams, facilitating operations like file transformations, uploads, and downloads.
|
||||
|
||||
#### Creating a SmartFile from a Buffer
|
||||
|
||||
```typescript
|
||||
const buffer: Buffer = Buffer.from('Sample data');
|
||||
const bufferSmartFile: SmartFile = await SmartFile.fromBuffer('./bufferFile.txt', buffer);
|
||||
await bufferSmartFile.write();
|
||||
```
|
||||
|
||||
### Using `VirtualDirectory` for Complex File Management
|
||||
|
||||
`VirtualDirectory` simplifies the management of multiple files that are otherwise scattered across different directories or created at runtime.
|
||||
|
||||
#### Creating a `VirtualDirectory`
|
||||
|
||||
To create a `VirtualDirectory` from an existing file directory:
|
||||
|
||||
```typescript
|
||||
const virtualDirectory = await VirtualDirectory.fromFsDirPath('./someDirectory');
|
||||
```
|
||||
|
||||
#### Adding More Files
|
||||
|
||||
You can add more `SmartFile` instances to your `VirtualDirectory`:
|
||||
|
||||
```typescript
|
||||
const additionalFiles = [
|
||||
await SmartFile.fromFilePath('./anotherDirectory/file1.txt'),
|
||||
await SmartFile.fromFilePath('./anotherDirectory/file2.txt')
|
||||
];
|
||||
virtualDirectory.addSmartfiles(additionalFiles);
|
||||
```
|
||||
|
||||
#### Saving `VirtualDirectory` to Disk
|
||||
|
||||
Save your entire `VirtualDirectory` to disk:
|
||||
|
||||
```typescript
|
||||
await virtualDirectory.saveToDisk('./outputDirectory');
|
||||
```
|
||||
|
||||
### Utilizing StreamFile for Efficient File Handling
|
||||
|
||||
Using `StreamFile` can be especially beneficial for large files or when performing streaming operations.
|
||||
|
||||
#### Streaming from a URL
|
||||
|
||||
`StreamFile` provides capabilities to stream files directly from URLs, making it easier to work with remote content.
|
||||
|
||||
```typescript
|
||||
const urlStreamFile: StreamFile = await StreamFile.fromUrl('https://example.com/largefile.zip');
|
||||
await urlStreamFile.writeToDisk('./downloadedFiles/largefile.zip');
|
||||
```
|
||||
|
||||
### Combining Buffer and Stream Approaches
|
||||
|
||||
Create `StreamFile` from a buffer for efficient, multi-use streams.
|
||||
|
||||
```typescript
|
||||
const buffer = Buffer.from('Streaming buffer content');
|
||||
const bufferStreamFile = StreamFile.fromBuffer(buffer, 'bufferBasedStream.txt');
|
||||
await bufferStreamFile.writeToDisk('./streams/bufferBasedStream.txt');
|
||||
```
|
||||
|
||||
### Read and Write Operations with StreamFile
|
||||
|
||||
Perform read and write operations efficiently using `StreamFile`.
|
||||
|
||||
```typescript
|
||||
const fileStream = await StreamFile.fromPath('./inputData/largeFile.data');
|
||||
await fileStream.writeToDisk('./outputData/largeFileCopy.data');
|
||||
```
|
||||
|
||||
Check for completeness of your read and write operations, ensuring the integrity of file content.
|
||||
|
||||
```typescript
|
||||
const readBuffer = await fileStream.getContentAsBuffer();
|
||||
console.log(readBuffer.toString());
|
||||
```
|
||||
|
||||
### Ensuring File Readiness for Streaming
|
||||
|
||||
Ensure a file is ready for streaming or create a custom readable stream incorporating data transformation.
|
||||
|
||||
```typescript
|
||||
const smartReadStream = new SmartReadStream('./incomingData/sample.data');
|
||||
smartReadStream.on('data', (chunk) => {
|
||||
console.log('New Data Chunk:', chunk.toString());
|
||||
});
|
||||
```
|
||||
|
||||
### File Transformation with SmartReadStream
|
||||
|
||||
Perform transformations on the stream of data while reading:
|
||||
|
||||
```typescript
|
||||
smartReadStream.on('data', (chunk) => {
|
||||
// Perform some transformation
|
||||
const transformedChunk = chunk.toString().toUpperCase();
|
||||
console.log('Transformed Data Chunk:', transformedChunk);
|
||||
});
|
||||
```
|
||||
|
||||
### Streaming with SmartReadStream
|
||||
|
||||
Stream data from a `SmartReadStream` to a file efficiently managing large datasets.
|
||||
|
||||
```typescript
|
||||
const transformedWriteStream = fs.createWriteStream('./processedData/transformed.data');
|
||||
smartReadStream.pipe(transformedWriteStream);
|
||||
```
|
||||
|
||||
`@push.rocks/smartfile` significantly simplifies the handling of complex file operations in Node.js projects, making these tasks straightforward while maintaining efficiency and ease of use. Explore and leverage these features to enhance your project's file management capabilities.
|
||||
Whether you're dealing with local files, directories, or files over the internet, `@push.rocks/smartfile` provides a comprehensive set of tools to streamline your workflow and reduce the complexity of file management in your Node.js projects.
|
||||
|
||||
## License and Legal Information
|
||||
|
||||
|
||||
@ -1,8 +1,8 @@
|
||||
/**
|
||||
* autocreated commitinfo by @push.rocks/commitinfo
|
||||
* autocreated commitinfo by @pushrocks/commitinfo
|
||||
*/
|
||||
export const commitinfo = {
|
||||
name: '@push.rocks/smartfile',
|
||||
version: '11.2.0',
|
||||
description: 'Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.'
|
||||
version: '11.0.9',
|
||||
description: 'provides a robust suite of tools for managing files in Node.js using TypeScript.'
|
||||
}
|
||||
|
||||
@ -91,7 +91,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
|
||||
});
|
||||
}
|
||||
|
||||
public static async fromUrl(urlArg: string) {
|
||||
public static async fromUrl (urlArg: string) {
|
||||
const response = await plugins.smartrequest.getBinary(urlArg);
|
||||
const smartfile = await SmartFile.fromBuffer(urlArg, response.body);
|
||||
return smartfile;
|
||||
@ -169,9 +169,7 @@ export class SmartFile extends plugins.smartjson.Smartjson {
|
||||
* - no argument write to exactly where the file was picked up
|
||||
*/
|
||||
public async write() {
|
||||
let writePath = plugins.smartpath.transform.makeAbsolute(this.path, this.base);
|
||||
console.log(`writing to ${writePath}`);
|
||||
await memory.toFs(this.contentBuffer, writePath);
|
||||
await memory.toFs(this.contentBuffer, plugins.path.join(this.base, this.path));
|
||||
}
|
||||
|
||||
/**
|
||||
@ -212,43 +210,6 @@ export class SmartFile extends plugins.smartjson.Smartjson {
|
||||
await fs.remove(plugins.path.join(this.base, this.path));
|
||||
}
|
||||
|
||||
/**
|
||||
* Renames the file to the specified new name.
|
||||
* - Updates the `path` property with the new name.
|
||||
* - Writes the file to the new location if it exists on disk.
|
||||
* @param newName The new name of the file (including extension if applicable).
|
||||
* @param writeToDisk (optional) If true, also renames the file on the disk.
|
||||
* @returns The updated file path after renaming.
|
||||
*/
|
||||
public async rename(newName: string, writeToDisk: boolean = false): Promise<string> {
|
||||
// Validate the new name
|
||||
if (!newName || typeof newName !== 'string') {
|
||||
throw new Error('Invalid new name provided.');
|
||||
}
|
||||
|
||||
// Extract the directory path
|
||||
const oldFilePath = this.path;
|
||||
const dirPath = plugins.path.dirname(this.path);
|
||||
|
||||
// Create the new file path
|
||||
const newFilePath = plugins.path.join(dirPath, newName);
|
||||
|
||||
// Update the `path` property
|
||||
this.path = newFilePath;
|
||||
|
||||
// Optionally write the renamed file to disk
|
||||
if (writeToDisk) {
|
||||
const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(oldFilePath, this.base);
|
||||
const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(newFilePath, this.base);
|
||||
|
||||
// Rename the file on disk
|
||||
await plugins.fsExtra.rename(oldAbsolutePath, newAbsolutePath);
|
||||
}
|
||||
|
||||
// Return the new path
|
||||
return this.path;
|
||||
}
|
||||
|
||||
// -----------------------------------------------
|
||||
// vinyl compatibility
|
||||
// -----------------------------------------------
|
||||
@ -343,11 +304,4 @@ export class SmartFile extends plugins.smartjson.Smartjson {
|
||||
stream.push(null); // Push null to signify the end of the stream (EOF)
|
||||
return stream;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the size of the file in bytes
|
||||
*/
|
||||
public async getSize(): Promise<number> {
|
||||
return this.contentBuffer.length;
|
||||
}
|
||||
}
|
||||
|
||||
@ -10,16 +10,26 @@ type TStreamSource = (streamFile: StreamFile) => Promise<Readable>;
|
||||
* It allows creating streams from a file path, a URL, or a buffer.
|
||||
*/
|
||||
export class StreamFile {
|
||||
// INSTANCE
|
||||
relativeFilePath?: string;
|
||||
private streamSource: TStreamSource;
|
||||
|
||||
// enable stream based multi use
|
||||
private cachedStreamBuffer?: Buffer;
|
||||
public multiUse: boolean;
|
||||
public used: boolean = false;
|
||||
|
||||
private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
|
||||
this.streamSource = streamSource;
|
||||
this.relativeFilePath = relativeFilePath;
|
||||
}
|
||||
|
||||
// STATIC
|
||||
|
||||
public static async fromPath(filePath: string): Promise<StreamFile> {
|
||||
const streamSource: TStreamSource = async (streamFileArg) => smartfileFsStream.createReadStream(filePath);
|
||||
const streamSource: TStreamSource = async (stremFileArg) => smartfileFsStream.createReadStream(filePath);
|
||||
const streamFile = new StreamFile(streamSource, filePath);
|
||||
streamFile.multiUse = true;
|
||||
streamFile.byteLengthComputeFunction = async () => {
|
||||
const stats = await smartfileFs.stat(filePath);
|
||||
return stats.size;
|
||||
}
|
||||
return streamFile;
|
||||
}
|
||||
|
||||
@ -27,10 +37,6 @@ export class StreamFile {
|
||||
const streamSource: TStreamSource = async (streamFileArg) => plugins.smartrequest.getStream(url); // Replace with actual plugin method
|
||||
const streamFile = new StreamFile(streamSource);
|
||||
streamFile.multiUse = true;
|
||||
streamFile.byteLengthComputeFunction = async () => {
|
||||
const response = await plugins.smartrequest.getBinary(url); // TODO: switch to future .getBinaryByteLength()
|
||||
return response.body.length;
|
||||
}
|
||||
return streamFile;
|
||||
}
|
||||
|
||||
@ -43,7 +49,6 @@ export class StreamFile {
|
||||
};
|
||||
const streamFile = new StreamFile(streamSource, relativeFilePath);
|
||||
streamFile.multiUse = true;
|
||||
streamFile.byteLengthComputeFunction = async () => buffer.length;
|
||||
return streamFile;
|
||||
}
|
||||
|
||||
@ -86,22 +91,6 @@ export class StreamFile {
|
||||
return streamFile;
|
||||
}
|
||||
|
||||
|
||||
// INSTANCE
|
||||
relativeFilePath?: string;
|
||||
private streamSource: TStreamSource;
|
||||
|
||||
// enable stream based multi use
|
||||
private cachedStreamBuffer?: Buffer;
|
||||
public multiUse: boolean;
|
||||
public used: boolean = false;
|
||||
public byteLengthComputeFunction: () => Promise<number>;
|
||||
|
||||
private constructor(streamSource: TStreamSource, relativeFilePath?: string) {
|
||||
this.streamSource = streamSource;
|
||||
this.relativeFilePath = relativeFilePath;
|
||||
}
|
||||
|
||||
// METHODS
|
||||
|
||||
private checkMultiUse() {
|
||||
@ -160,15 +149,4 @@ export class StreamFile {
|
||||
const contentBuffer = await this.getContentAsBuffer();
|
||||
return contentBuffer.toString(formatArg);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the size of the file content in bytes.
|
||||
*/
|
||||
public async getSize(): Promise<number> {
|
||||
if (this.byteLengthComputeFunction) {
|
||||
return this.byteLengthComputeFunction();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
230
ts/fs.ts
230
ts/fs.ts
@ -72,23 +72,25 @@ export const isFile = (pathArg): boolean => {
|
||||
===============================================================*/
|
||||
|
||||
/**
|
||||
* copies a file or directory from A to B on the local disk
|
||||
* copies a file from A to B on the local disk
|
||||
*/
|
||||
export const copy = async (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptions & { replaceTargetDir?: boolean }): Promise<void> => {
|
||||
if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
|
||||
await remove(toArg);
|
||||
}
|
||||
return await plugins.fsExtra.copy(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptions);
|
||||
export const copy = async (fromArg: string, toArg: string): Promise<boolean> => {
|
||||
const done = plugins.smartpromise.defer<boolean>();
|
||||
plugins.fsExtra.copy(fromArg, toArg, {}, (err) => {
|
||||
if (err) {
|
||||
throw new Error(`Could not copy from ${fromArg} to ${toArg}: ${err}`);
|
||||
}
|
||||
done.resolve(true);
|
||||
});
|
||||
return done.promise;
|
||||
};
|
||||
|
||||
/**
|
||||
* copies a file or directory SYNCHRONOUSLY from A to B on the local disk
|
||||
* copies a file SYNCHRONOUSLY from A to B on the local disk
|
||||
*/
|
||||
export const copySync = (fromArg: string, toArg: string, optionsArg?: plugins.fsExtra.CopyOptionsSync & { replaceTargetDir?: boolean }): void => {
|
||||
if (optionsArg?.replaceTargetDir && isDirectory(fromArg) && isDirectory(toArg)) {
|
||||
removeSync(toArg);
|
||||
}
|
||||
return plugins.fsExtra.copySync(fromArg, toArg, optionsArg as plugins.fsExtra.CopyOptionsSync);
|
||||
export const copySync = (fromArg: string, toArg: string): boolean => {
|
||||
plugins.fsExtra.copySync(fromArg, toArg);
|
||||
return true;
|
||||
};
|
||||
|
||||
/**
|
||||
@ -188,8 +190,7 @@ export const removeManySync = (filePathArrayArg: string[]): void => {
|
||||
===============================================================*/
|
||||
|
||||
/**
|
||||
* reads a file content to an object
|
||||
* good for JSON, YAML, TOML, etc.
|
||||
*
|
||||
* @param filePathArg
|
||||
* @param fileTypeArg
|
||||
* @returns {any}
|
||||
@ -198,19 +199,14 @@ export const toObjectSync = (filePathArg, fileTypeArg?) => {
|
||||
const fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
|
||||
let fileType;
|
||||
fileTypeArg ? (fileType = fileTypeArg) : (fileType = interpreter.filetype(filePathArg));
|
||||
try {
|
||||
return interpreter.objectFile(fileString, fileType);
|
||||
} catch (err) {
|
||||
err.message = `Failed to read file at ${filePathArg}` + err.message;
|
||||
throw err;
|
||||
}
|
||||
return interpreter.objectFile(fileString, fileType);
|
||||
};
|
||||
|
||||
/**
|
||||
* reads a file content to a String
|
||||
*/
|
||||
export const toStringSync = (filePath: string): string => {
|
||||
const encoding = plugins.smartmime.getEncodingForPathSync(filePath);
|
||||
const encoding = plugins.smartmime.getEncoding(filePath);
|
||||
let fileString: string | Buffer = plugins.fsExtra.readFileSync(filePath, encoding);
|
||||
if (Buffer.isBuffer(fileString)) {
|
||||
fileString = fileString.toString('binary');
|
||||
@ -395,174 +391,53 @@ export const listFileTree = async (
|
||||
|
||||
/**
|
||||
* Watches for file stability before resolving the promise.
|
||||
* Ensures that the directory/file exists before setting up the watcher.
|
||||
*
|
||||
* **New behavior**: If the given path is a directory, this function will:
|
||||
* 1. Wait for that directory to exist (creating a timeout if needed).
|
||||
* 2. Watch the directory until at least one file appears.
|
||||
* 3. Then wait for the first file in the directory to stabilize before resolving.
|
||||
*
|
||||
* @param fileOrDirPathArg The path of the file or directory to monitor.
|
||||
* @param timeoutMs The maximum time to wait for the file to stabilize (in milliseconds). Default is 60 seconds.
|
||||
* @returns A promise that resolves when the target is stable or rejects on timeout/error.
|
||||
*/
|
||||
export const waitForFileToBeReady = async (
|
||||
fileOrDirPathArg: string,
|
||||
timeoutMs: number = 60000
|
||||
): Promise<void> => {
|
||||
const startTime = Date.now();
|
||||
|
||||
/**
|
||||
* Ensure that a path (file or directory) exists. If it doesn't yet exist,
|
||||
* wait until it does (or time out).
|
||||
* @param pathToCheck The file or directory path to check.
|
||||
*/
|
||||
const ensurePathExists = async (pathToCheck: string): Promise<void> => {
|
||||
while (true) {
|
||||
try {
|
||||
await plugins.smartpromise.fromCallback((cb) =>
|
||||
plugins.fs.access(pathToCheck, plugins.fs.constants.F_OK, cb)
|
||||
);
|
||||
return;
|
||||
} catch (err: any) {
|
||||
if (err.code !== 'ENOENT') {
|
||||
throw err; // Propagate unexpected errors
|
||||
}
|
||||
if (Date.now() - startTime > timeoutMs) {
|
||||
throw new Error(`Timeout waiting for path to exist: ${pathToCheck}`);
|
||||
}
|
||||
await plugins.smartdelay.delayFor(500);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if a file (not directory) is stable by comparing sizes
|
||||
* across successive checks.
|
||||
* @param filePathArg The path of the file to check.
|
||||
* @returns A promise that resolves once the file stops changing.
|
||||
*/
|
||||
const waitForSingleFileToBeStable = async (filePathArg: string): Promise<void> => {
|
||||
export const waitForFileToBeReady = (filePathArg: string): Promise<void> => {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
let lastFileSize = -1;
|
||||
let fileIsStable = false;
|
||||
|
||||
// We'll create a helper for repeated stats-checking logic
|
||||
const checkFileStability = async () => {
|
||||
try {
|
||||
const stats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
|
||||
plugins.fs.stat(filePathArg, cb)
|
||||
);
|
||||
if (stats.isDirectory()) {
|
||||
// If it unexpectedly turns out to be a directory here, throw
|
||||
throw new Error(`Expected a file but found a directory: ${filePathArg}`);
|
||||
}
|
||||
if (stats.size === lastFileSize) {
|
||||
let currentFileSize: number;
|
||||
const deferred = plugins.smartpromise.defer();
|
||||
plugins.fs.stat(filePathArg, (err, stats) => {
|
||||
if (err) {
|
||||
fileIsStable = true;
|
||||
} else {
|
||||
lastFileSize = stats.size;
|
||||
fileIsStable = false;
|
||||
}
|
||||
} catch (err: any) {
|
||||
// Ignore only if file not found
|
||||
if (err.code !== 'ENOENT') {
|
||||
throw err;
|
||||
watcher.close();
|
||||
reject(err);
|
||||
return;
|
||||
}
|
||||
currentFileSize = stats.size;
|
||||
deferred.resolve();
|
||||
});
|
||||
await deferred.promise;
|
||||
if (currentFileSize === lastFileSize) {
|
||||
fileIsStable = true;
|
||||
await plugins.smartdelay.delayFor(100);
|
||||
resolve();
|
||||
}
|
||||
lastFileSize = currentFileSize;
|
||||
};
|
||||
|
||||
// Ensure file exists first
|
||||
await ensurePathExists(filePathArg);
|
||||
|
||||
// Set up a watcher on the file itself
|
||||
const fileWatcher = plugins.fs.watch(filePathArg, { persistent: true }, async () => {
|
||||
if (!fileIsStable) {
|
||||
await checkFileStability();
|
||||
const watcher = plugins.fs.watch(filePathArg, (eventType, filename) => {
|
||||
if (eventType === 'change') {
|
||||
checkFileStability();
|
||||
}
|
||||
});
|
||||
|
||||
try {
|
||||
// Poll until stable or timeout
|
||||
while (!fileIsStable) {
|
||||
if (Date.now() - startTime > timeoutMs) {
|
||||
throw new Error(`Timeout waiting for file to stabilize: ${filePathArg}`);
|
||||
}
|
||||
await checkFileStability();
|
||||
if (!fileIsStable) {
|
||||
await plugins.smartdelay.delayFor(1000);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
fileWatcher.close();
|
||||
}
|
||||
};
|
||||
watcher.on('error', (error) => {
|
||||
watcher.close();
|
||||
reject(error);
|
||||
});
|
||||
|
||||
/**
|
||||
* Main logic: check if we have a directory or file at fileOrDirPathArg.
|
||||
* If directory, wait for first file in the directory to appear and stabilize.
|
||||
* If file, do the old single-file wait logic.
|
||||
*/
|
||||
const statsForGivenPath = await (async () => {
|
||||
try {
|
||||
await ensurePathExists(fileOrDirPathArg);
|
||||
return await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
|
||||
plugins.fs.stat(fileOrDirPathArg, cb)
|
||||
);
|
||||
} catch (err) {
|
||||
// If there's an error (including timeout), just rethrow
|
||||
throw err;
|
||||
}
|
||||
})();
|
||||
|
||||
if (!statsForGivenPath.isDirectory()) {
|
||||
// It's a file – just do the single-file stability wait
|
||||
await waitForSingleFileToBeStable(fileOrDirPathArg);
|
||||
return;
|
||||
}
|
||||
|
||||
// Otherwise, it's a directory. Wait for the first file inside to appear and be stable
|
||||
const dirPath = fileOrDirPathArg;
|
||||
|
||||
// Helper to find the first file in the directory if it exists
|
||||
const getFirstFileInDirectory = async (): Promise<string | null> => {
|
||||
const entries = await plugins.smartpromise.fromCallback<string[]>((cb) =>
|
||||
plugins.fs.readdir(dirPath, cb)
|
||||
);
|
||||
// We only want actual files, not subdirectories
|
||||
for (const entry of entries) {
|
||||
const entryPath = plugins.path.join(dirPath, entry);
|
||||
const entryStats = await plugins.smartpromise.fromCallback<plugins.fs.Stats>((cb) =>
|
||||
plugins.fs.stat(entryPath, cb)
|
||||
);
|
||||
if (entryStats.isFile()) {
|
||||
return entryPath;
|
||||
while (!fileIsStable) {
|
||||
await checkFileStability();
|
||||
if (!fileIsStable) {
|
||||
await plugins.smartdelay.delayFor(5000);
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
|
||||
// Wait for a file to appear in this directory
|
||||
let firstFilePath = await getFirstFileInDirectory();
|
||||
if (!firstFilePath) {
|
||||
// Set up a watcher on the directory to see if a file appears
|
||||
const directoryWatcher = plugins.fs.watch(dirPath, { persistent: true });
|
||||
try {
|
||||
// We'll poll for the existence of a file in that directory
|
||||
while (!firstFilePath) {
|
||||
if (Date.now() - startTime > timeoutMs) {
|
||||
throw new Error(`Timeout waiting for a file to appear in directory: ${dirPath}`);
|
||||
}
|
||||
firstFilePath = await getFirstFileInDirectory();
|
||||
if (!firstFilePath) {
|
||||
await plugins.smartdelay.delayFor(1000);
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
directoryWatcher.close();
|
||||
}
|
||||
}
|
||||
|
||||
// Now that we have a file path, wait for that file to stabilize
|
||||
await waitForSingleFileToBeStable(firstFilePath);
|
||||
watcher.close();
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
@ -572,8 +447,8 @@ export const waitForFileToBeReady = async (
|
||||
* @param fileBaseArg
|
||||
*/
|
||||
export let toFs = async (
|
||||
fileContentArg: string | Buffer | SmartFile | StreamFile,
|
||||
filePathArg: string,
|
||||
fileContentArg: string | Buffer | SmartFile | StreamFile,
|
||||
optionsArg: {
|
||||
respectRelative?: boolean;
|
||||
} = {}
|
||||
@ -610,6 +485,7 @@ export let toFs = async (
|
||||
return await done.promise;
|
||||
};
|
||||
|
||||
export const stat = async (filePathArg: string) => {
|
||||
return plugins.fsPromises.stat(filePathArg);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@ -1,10 +1,9 @@
|
||||
// node native scope
|
||||
import * as fs from 'fs';
|
||||
import * as fsPromises from 'fs/promises';
|
||||
import * as path from 'path';
|
||||
import * as stream from 'stream';
|
||||
|
||||
export { fs, fsPromises, path, stream };
|
||||
export { fs, path, stream };
|
||||
|
||||
// @pushrocks scope
|
||||
import * as lik from '@push.rocks/lik';
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user